redland/0000755000176200001440000000000015116210440011655 5ustar liggesusersredland/tests/0000755000176200001440000000000013366717502013037 5ustar liggesusersredland/tests/testthat/0000755000176200001440000000000015114705026014666 5ustar liggesusersredland/tests/testthat/test.Query.R0000644000176200001440000001202714156163010017072 0ustar liggesuserstest_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("Query works", { library(redland) world <- new("World") expect_false(is.null(world)) world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") # Literal for object node has RDF language tag stmt <- new("Statement", world = world, subject="", predicate="http://schema.org/name", object="Maëlle Salmon", language="fr") addStatement(model, stmt) queryString <-'SELECT ?s ?p ?o WHERE { ?s ?p ?o}' query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) results <- getResults(query, model, "turtle") expect_true(grepl("http://schema.org/name", results)) # The Redlands library can return UTF characters that are outside the # ASCII range as the unicode literal string, i.e. https://en.wikipedia.org/wiki/List_of_Unicode_characters. # If 'stringi' is available, then check the original representation, otherwise check the escaped codepoint # representation. if(require("stringi", character.only = TRUE)) { expect_match(stringi::stri_unescape_unicode(results), "Maëlle Salmon") } else { expect_match(results$o, '"Ma\\\\u00EBlle Salmon"@fr') } freeQuery(query) rm(query) freeStorage(storage) rm(storage) freeModel(model) rm(model) freeWorld(world) rm(world) }) test_that("getResults, writeResults work", { library(redland) world <- new("World") expect_false(is.null(world)) storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") stmt <- new("Statement", world=world, subject="https://orcid.org/0000-0002-2192-403X", predicate="http://www.w3.org/ns/prov#Agent", object="slaughter", objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") status <- addStatement(model, stmt) queryString <- paste("PREFIX orcid: ", "PREFIX dataone: ", "PREFIX prov: ", "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) # Return all results as a string results <- getResults(query, model, "rdfxml") expect_true(grepl("0000-0002-2192-403X", results)) expect_true(grepl("slaughter", results)) results <- getResults(query, model, "turtle") expect_true(grepl("slaughter", results)) expect_true(grepl("0000-0002-2192-403X", results)) results <- getResults(query, model, "json") expect_true(grepl("slaughter", results)) expect_true(grepl("0000-0002-2192-403X", results)) # When the query object is no longer needed, the resources it had allocated can be freed. freeQuery(query) rm(query) # Test writeResults world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") stmt <- new("Statement", world=world, subject="https://orcid.org/0000-0002-2192-403X", predicate="http://www.w3.org/ns/prov#Agent", object="slaughter", objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") status <- addStatement(model, stmt) queryString <- paste("PREFIX orcid: ", "PREFIX dataone: ", "PREFIX prov: ", "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) # Return all results as a string tf <- tempfile() writeResults(query, model, file=tf, mimeType="application/x-turtle") inbuf <- readLines(tf) expect_true(any(grepl("slaughter", inbuf))) expect_true(any(grepl("0000-0002-2192-403X", inbuf))) # Ntriples tf <- tempfile() writeResults(query, model, file=tf, mimeType="text/plain") inbuf <- readLines(tf) expect_true(any(grepl("slaughter", inbuf))) expect_true(any(grepl("0000-0002-2192-403X", inbuf))) tf <- tempfile() writeResults(query, model, file=tf, mimeType="application/json") inbuf <- readLines(tf) expect_true(any(grepl("slaughter", inbuf))) expect_true(any(grepl("0000-0002-2192-403X", inbuf))) tf <- tempfile() writeResults(query, model, file=tf, mimeType="text/html") inbuf <- readLines(tf) expect_true(any(grepl("slaughter", inbuf))) expect_true(any(grepl("0000-0002-2192-403X", inbuf))) # When the query object is no longer needed, the resources it had allocated can be freed. freeQuery(query) rm(query) freeStorage(storage) rm(storage) freeModel(model) rm(model) freeWorld(world) rm(world) })redland/tests/testthat/test.Statement.R0000644000176200001440000000745114156163010017736 0ustar liggesuserstest_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("Statement constructor", { library(redland) world <- new("World") expect_false(is.null(world)) # Test creating Subject, predicate, and object Nodes subject <- new("Node", world, literal="subject") expect_match(class(subject@librdf_node), "_p_librdf_node_s") predicate <- new("Node", world, literal="subject") expect_match(class(predicate@librdf_node), "_p_librdf_node_s") object <- new("Node", world, literal="subject") expect_match(class(object@librdf_node), "_p_librdf_node_s") # Test creating the Statement stmt <- new("Statement", world, subject, predicate, object) expect_false(is.null(stmt)) expect_match(class(stmt@librdf_statement), "_p_librdf_statement_s") # Test that statement creation fails if world is not provided or is null err <- try(stmt <- new("Statement", world=NULL, subject=subject, predicate=predicate, object=object), silent=TRUE) expect_match(class(err), "try-error") # Test that statement creation fails if subject, predicate, or object is not provided or is null err <- try(stmt <- new("Statement", world=world, subject=NULL, predicate=predicate, object=object), silent=TRUE) expect_match(class(err), "try-error") err <- try(stmt <- new("Statement", world=world, subject=subject, predicate=NULL, object=object), silent=TRUE) expect_match(class(err), "try-error") err <- try(stmt <- new("Statement", world=world, subject=subject, predicate=predicate, object=NULL), silent=TRUE) expect_match(class(err), "try-error") # Test statement creation when subject, predicate, object are passed in as character and RDF type is not specified stmt <- new("Statement", world=world, subject="https://cn.dataone.org/cn/v1/resolve/resourceMap_5cbcdecd-6b0e-4b24-a0be-20291b2e49a7#aggregation", predicate="http://purl.org/dc/terms/identifier", object="resourceMap_5cbcdecd-6b0e-4b24-a0be-20291b2e49a7^^xsd:string") expect_match(getTermType(stmt, "subject"), "resource") expect_match(getTermType(stmt, "predicate"), "resource") expect_match(getTermType(stmt, "object"), "literal") # Test stmt <- new("Statement", world=world, subject="_:foo1", predicate="http://purl.org/dc/terms/identifier", object=NULL) expect_match(getTermType(stmt, "subject"), "blank") expect_match(getTermType(stmt, "predicate"), "resource") expect_match(getTermType(stmt, "object"), "blank") err <- try(freeStatement(stmt), silent=TRUE) expect_false(class(err) == "try-error") stmt <- new("Statement", world=world, subject=NULL, predicate="http://purl.org/dc/terms/identifier", object="id1234") expect_match(getTermType(stmt, "subject"), "blank") expect_match(getTermType(stmt, "predicate"), "resource") expect_match(getTermType(stmt, "object"), "literal") err <- try(freeStatement(stmt), silent=TRUE) expect_false(class(err) == "try-error") # Test statement creation when subject, predicate and object are passed in as charater and RDF types are specified stmt <- new("Statement", world=world, subject="http://www.exmaple.com/subject", predicate="http://purl.org/dc/terms/identifier", object="http://www.exmaple.com/object", subjectType="blank", objectType="literal") expect_match(getTermType(stmt, "subject"), "blank") expect_match(getTermType(stmt, "predicate"), "resource") expect_match(getTermType(stmt, "object"), "literal") err <- try(freeStatement(stmt), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeWorld(world), silent=TRUE) expect_false(class(err) == "try-error") })redland/tests/testthat/test.redland_base.R0000644000176200001440000000613414156163010020372 0ustar liggesuserstest_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("librdf basic functions", { library(redland) world <- librdf_new_world(); expect_match(class(world), "_p_librdf_world_s") storage <- librdf_new_storage(world,'hashes','dummy',"new=yes,hash-type='memory'") expect_match(class(storage), "_p_librdf_storage_s") model <- librdf_new_model(world,storage,'') expect_match(class(model), "_p_librdf_model_s") parser <- librdf_new_parser(world,'rdfxml','application/rdf+xml',NULL) expect_match(class(parser), "_p_librdf_parser_s") uri <- librdf_new_uri(world,paste0('file:',system.file('extdata/dc.rdf', package='redland'))) expect_match(class(uri), "_p_librdf_uri_s") rv <- librdf_parser_parse_into_model(parser,uri,uri,model) expect_equal(rv, 0) librdf_free_uri(uri); librdf_free_parser(parser); query <- librdf_new_query(world, 'sparql', NULL, "PREFIX dc: SELECT ?a ?c ?d WHERE { ?a dc:title ?c . OPTIONAL { ?a dc:related ?d } }", NULL) results <- librdf_model_query_execute(model, query); expect_false(is.null(results)) expect_match(class(results), "_p_librdf_query_results") # Convert the whole sparql result to a string and check its value qstr <- librdf_query_results_to_string2(results, "rdfxml", "application/rdf+xml", NULL, NULL) expect_match(qstr, "http://www.dajobe.org/") expect_match(qstr, "Beckett") # Test adding a new Statement to the model about <- "http://matt.magisa.org/" subject <- librdf_new_node_from_uri_string(world, about) expect_false(is.null(subject)) expect_match(class(subject), "_p_librdf_node_s") pred <- librdf_new_node_from_uri_string(world, "http://purl.org/dc/elements/1.1/title") expect_false(is.null(pred)) expect_match(class(pred), "_p_librdf_node_s") object <- librdf_new_node_from_literal(world, "Matt Jones' Home Page", "", 0) expect_false(is.null(object)) expect_match(class(object), "_p_librdf_node_s") statement <- librdf_new_statement_from_nodes(world, subject, pred, object) expect_false(is.null(statement)) expect_match(class(statement), "_p_librdf_statement_s") rc <- librdf_model_add_statement(model, statement) expect_equal(rc, 0) # Don't need to call librdf_free_node, just librdf_free_statement. librdf_free_statement(statement) # Test serialization of the model to a text file serializer <- librdf_new_serializer(world, "rdfxml", "", NULL); expect_false(is.null(serializer)) expect_match(class(serializer), "_p_librdf_serializer") base = librdf_new_uri(world, "http://example.org/base.rdf"); filePath <- tempfile(pattern = "file", tmpdir = tempdir(), fileext = ".rdf") librdf_serializer_serialize_model_to_file(serializer,filePath,base,model); expect_true(file.exists(filePath)) unlink(filePath) # Free resources librdf_free_serializer(serializer); librdf_free_uri(base); librdf_free_model(model); librdf_free_storage(storage); }) redland/tests/testthat/test.Node.R0000644000176200001440000000660114156163010016653 0ustar liggesuserstest_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("Node constructor", { library(redland) world <- new("World") expect_false(is.null(world)) # Test creating a blank node node <- new("Node", world) expect_false(is.null(node)) expect_match(class(node), "Node") expect_match(getNodeType(node), "blank") # Test creating a blank node with librdf generated identifier node <- new("Node", world, blank=NULL) expect_match(class(node@librdf_node), "_p_librdf_node_s") expect_match(getNodeType(node), "blank") # Test creating a blank node with librdf generated identifier node <- new("Node", world, blank="_:1234") expect_match(class(node@librdf_node), "_p_librdf_node_s") expect_match(getNodeType(node), "blank") # Test creating a node with a literal value node <- new("Node", world, "Fee Fi Fo Fum") expect_match(class(node@librdf_node), "_p_librdf_node_s") expect_match(getNodeType(node), "literal") # err <- try(freeNode(node), silent=TRUE) # expect_match(class(err), not("try-error")) # Test creating a node with a literal value node <- new("Node", world, literal="Fee Fi Fo Fum") expect_match(class(node@librdf_node), "_p_librdf_node_s") expect_match(getNodeType(node), "literal") # Test creating a node with a URI value node <- new("Node", world, uri="http://www.example.com/") expect_match(class(node@librdf_node), "_p_librdf_node_s") expect_match(getNodeType(node), "resource") # Test that node creation fails if world is not provided or is null err <- try(node <- new("Node", literal="Fee Fi Fo Fum"), silent=TRUE) expect_match(class(err), "try-error") err <- try(node <- new("Node", world=NULL, literal="Fee Fi Fo Fum"), silent=TRUE) expect_match(class(err), "try-error") # Test that node values can be assigned and retrieved # a blank node is created with a unique identifier generated by librdf node <- new("Node", world, blank=NULL) expect_gt(nchar(getNodeValue(node)), 0) # a blank node is created with the user specified identifier, i.e. "_:id1" # THe blank node id will be returned as a string node <- new("Node", world, blank="_:b1") expect_match(getNodeValue(node), "_:b1") # a node type of 'literal' is created node <- new("Node", world, literal="A Node Value") expect_match(getNodeValue(node), "A Node Value") # a Node type of 'resource' is created node <- new("Node", world, uri="http://www.example.com") expect_match(getNodeValue(node), "http://www.example.com") # Create a literal node without a language tag node <- new("Node", world, literal="just plain text") expect_match(getNodeValue(node), "just plain text") node <- new("Node", world, literal="Jean Pierre Rampal", language="fr") expect_match(getNodeValue(node), '\"Jean Pierre Rampal"@fr\"') # Activate this check when testthat properly handles UTF-8 in tests. This # test works fine from the command line on all platforms, but when testthat # reads a test in, it is reading in the code as ASCII and ignoring the package # encoding, therefor the test is not performed with the correct string. # # Create a literal node, specifying a language encoding #node <- new("Node", world, literal="Gérard de La Martinière", language="fr") #expect_match(getNodeValue(node), "\"Gérard de La Martinière\"@fr\"") })redland/tests/testthat/test.World.R0000644000176200001440000000067714156163010017064 0ustar liggesuserstest_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("World constructor", { library(redland) world <- new("World"); expect_match(class(world), "World") expect_match(class(world@librdf_world), "_p_librdf_world_s") err <- try(freeWorld(world), silent=TRUE) expect_false(class(err) == "try-error") })redland/tests/testthat/test.Parser.R0000644000176200001440000000402714156163010017222 0ustar liggesuserstest_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("Parser constructor", { library(redland) world <- new("World") expect_false(is.null(world)) # Test creating the Storage system storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") expect_false(is.null(storage)) expect_match(class(storage@librdf_storage), "_p_librdf_storage_s") # Test creating the Model model <- new("Model", world, storage, options="") expect_false(is.null(model)) expect_match(class(model@librdf_model), "_p_librdf_model_s") # Test that model creation fails if world is not provided or is null err <- try(model <- new("Model", world=NULL, storage, options=""), silent=TRUE) expect_match(class(err), "try-error") expect_false(is.null(model)) expect_match(class(model@librdf_model), "_p_librdf_model_s") # Test parsing an RDF document into a Model parser <- new("Parser", world) expect_false(is.null(parser)) expect_match(class(parser@librdf_parser), "_p_librdf_parser_s") parseFileIntoModel(parser, world, system.file('extdata/example.rdf', package='redland'), model) # Test creating a Serializer and serializing the content just parsed into the model serializer <- new("Serializer", world) expect_false(is.null(serializer)) expect_match(class(serializer@librdf_serializer), "_p_librdf_serializer_s") # Test performing a serialization on an RDF model rdf <- serializeToCharacter(serializer, world, model) expect_match(rdf, "John Smith") err <- try(freeModel(model), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeStorage(storage), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeParser(parser), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeSerializer(serializer), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeWorld(world), silent=TRUE) expect_false(class(err) == "try-error") }) redland/tests/testthat/test.Model.R0000644000176200001440000000402114156163010017020 0ustar liggesuserstest_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("Model constructor", { library(redland) world <- new("World") expect_false(is.null(world)) # Test creating the Storage system storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") expect_false(is.null(storage)) expect_match(class(storage@librdf_storage), "_p_librdf_storage_s") # Test creating the Model model <- new("Model", world, storage, options="") expect_false(is.null(model)) expect_match(class(model@librdf_model), "_p_librdf_model_s") # Test that model creation fails if world is not provided or is null err <- try(model <- new("Model", world=NULL, storage, options=""), silent=TRUE) expect_match(class(err), "try-error") # Test that model creation fails if storage is not provided or is null err <- try(model <- new("Model", world, storage=NULL, options=""), silent=TRUE) expect_match(class(err), "try-error") # Test adding a Statement to the Model subject <- new("Node", world, uri="http://www.dajobe.org") expect_match(class(subject@librdf_node), "_p_librdf_node_s") predicate <- new("Node", world, uri="http://purl.org/dc/elements/1.1/creator") expect_match(class(predicate@librdf_node), "_p_librdf_node_s") object <- new("Node", world, literal="John Smith") expect_match(class(object@librdf_node), "_p_librdf_node_s") statement <- new("Statement", world, subject, predicate, object) expect_false(is.null(statement)) expect_match(class(statement@librdf_statement), "_p_librdf_statement_s") addStatement(model, statement) err <- try(freeStatement(statement), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeModel(model), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeStorage(storage), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeWorld(world), silent=TRUE) expect_false(class(err) == "try-error") })redland/tests/testthat/test.Storage.R0000644000176200001440000000172514156163010017374 0ustar liggesusers test_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("Storage constructor", { library(redland) world <- new("World") expect_false(is.null(world)) # Test creating the Storage system storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") expect_false(is.null(storage)) expect_match(class(storage@librdf_storage), "_p_librdf_storage_s") # Test that storage creation fails if world is not provided or is null err <- try(storage <- new("Storage", world=NULL, "hashes", name="", options="hash-type='memory'"), silent=TRUE) expect_match(class(err), "try-error") # Test that storage creation succeeds even if type and related options are not provided (use defaults) err <- try(storage <- new("Storage", world=world), silent=TRUE) expect_match(class(err), "Storage") })redland/tests/testthat/test.Serializer.R0000644000176200001440000000563214156163010020102 0ustar liggesuserstest_that("redland library loads", { library(redland) # Add a line to this test to prevent 'Empty test' (skipped) msg. expect_true(require(redland)) }) test_that("Serializer constructor", { library(redland) world <- new("World") expect_false(is.null(world)) # Test creating the Storage system storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") expect_false(is.null(storage)) expect_match(class(storage@librdf_storage), "_p_librdf_storage_s") # Test creating the Model model <- new("Model", world, storage, options="") expect_false(is.null(model)) expect_match(class(model@librdf_model), "_p_librdf_model_s") # Test that model creation fails if world is not provided or is null err <- try(model <- new("Model", world=NULL, storage, options=""), silent=TRUE) expect_match(class(err), "try-error") expect_false(is.null(model)) expect_match(class(model@librdf_model), "_p_librdf_model_s") # Test adding a Statement to the Model subject <- new("Node", world, uri="http://www.johnsmith.com/") expect_match(class(subject@librdf_node), "_p_librdf_node_s") predicate <- new("Node", world, uri="http://purl.org/dc/elements/1.1/creator") expect_match(class(predicate@librdf_node), "_p_librdf_node_s") object <- new("Node", world, literal="John Smith", datatype_uri="http://www.w3.org/2001/XMLSchema#string") expect_match(class(object@librdf_node), "_p_librdf_node_s") statement <- new("Statement", world, subject, predicate, object) expect_false(is.null(statement)) expect_match(class(statement@librdf_statement), "_p_librdf_statement_s") addStatement(model, statement) # Test creating a Serializer serializer <- new("Serializer", world, mimeType="application/rdf+xml") expect_false(is.null(serializer)) expect_match(class(serializer@librdf_serializer), "_p_librdf_serializer_s") # Test adding a namespace to a serializer status <- setNameSpace(serializer, world, namespace="http://purl.org/dc/elements/1.1/", prefix="dc") expect_equal(status, 0) # Test serialization of an RDF model to a string rdf <- serializeToCharacter(serializer, world, model, "") expect_match(rdf, "John Smith") # Test serialization of an RDF model to a file filePath <- tempfile(pattern = "file", tmpdir = tempdir(), fileext = ".rdf") status <- serializeToFile(serializer, world, model, filePath) found <- grep("John Smith", readLines(filePath)) expect_gt(found, 0) unlink(filePath) err <- try(freeStatement(statement), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeSerializer(serializer), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeModel(model), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeStorage(storage), silent=TRUE) expect_false(class(err) == "try-error") err <- try(freeWorld(world), silent=TRUE) expect_false(class(err) == "try-error") })redland/tests/spelling.R0000644000176200001440000000020213366717502014771 0ustar liggesusersif(requireNamespace('spelling', quietly=TRUE)) spelling::spell_check_test(vignettes = TRUE, error = FALSE, skip_on_cran = TRUE) redland/tests/test-all.R0000644000176200001440000000131712533713100014672 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # library("testthat") test_check("redland") redland/MD50000644000176200001440000004706515116210440012201 0ustar liggesusers630411265a80e9bb2d92dc9139eb323c *DESCRIPTION c3cb195e983b1e867719a299e4cb1c91 *NAMESPACE 5cd54ba754364fc164199238549a0591 *NEWS 0d74da17afa3269c6f8540f52335695c *R/Model.R 10587a075538084f3e45949bffe85142 *R/Node.R f1b6618f65c2e46255f6793aef877240 *R/Parser.R e667210d3ab37b171077deb8725af870 *R/Query.R 35ce9739a49e882381ec945b4776310f *R/QueryResults.R a5c3ac0aaa95bfab846caf46c726f635 *R/Serializer.R bedfc8ca3387c81f3e97167f98c7b6d1 *R/Statement.R 4aaa2dc1b85880e789b6c198e5b1511d *R/Storage.R dd6dceb0305389b12dcfd9b41c39edbf *R/World.R de68481a3df4e9b991aa75f691a27c23 *R/mergeNamespace_roclet.R a9422ccccc0daefd7e3256ecfeeb3352 *R/redland-package.R 3365543d167e6e9ea1e909b29222839d *R/redland.R 1529a88433d2deafba85d668b5960997 *R/util.R 14be1699edaa34a92fe0c44ef0aef8d1 *README.md 7e11a88391f38a36619a08ee6844dda9 *build/vignette.rds 6071edd604dbeb75308cfbedc7790398 *cleanup 11bd5238291e7520bb0d65bcbda58952 *configure d41d8cd98f00b204e9800998ecf8427e *configure.win d3855d3fbaac2d0a20d1e51d67e1eee3 *inst/CITATION 8e7fc1ae6e858682dcf04bfb0fb39624 *inst/COPYRIGHTS b951265031ccaa396652afff6018d242 *inst/Makefile 49c50f27a81131f88fc681052308eddc *inst/NOTICE 0e09f7acf510ac78b14c1bb770cb2626 *inst/WORDLIST 7ff66e4f249e5b99b9e970a97f538637 *inst/config.log 4ded9458d873504842190019bc3ce36c *inst/config.status 6fece89ee8533c8ce26c5f911020357d *inst/doc/redland_overview.R 3499da88a7682576ca0b95a0ad2b3703 *inst/doc/redland_overview.Rmd 50bdeeafca176df3c9bfbd5dd9f6c37d *inst/doc/redland_overview.html 67f3001bf4fce8f92ff0b4ebea9927dc *inst/extdata/dc.rdf 59940b488bb6ae076454faefbc439528 *inst/extdata/example.rdf 71780eef134c4c6a0955e8643dd770b9 *man/Model-class.Rd 84047071fb6f3f0e10366e4f462b3904 *man/Model-initialize.Rd 51236c71c1fdebf9307b33fb63a5e5e6 *man/Node-class.Rd 65686adb65fd71717b7d53c89061eea8 *man/Node-initialize.Rd ae8a6639d847791b1bc40aec7d703f7d *man/Parser-class.Rd d5b43a8a417496311344e36ee07191e6 *man/Parser-initialize.Rd c58325455bbe4e92f626a842c833effa *man/Query-class.Rd acfdde407ff3bcc99143d13c8f12173f *man/Query-initialize.Rd adc40eb81ab746e295a150d44fbf6660 *man/QueryResults-class.Rd fd8efd117a08c4f246fc9ac92de7a7d3 *man/QueryResults-initialize.Rd b055ff2e70c8674bdf21799bdb9cf2f4 *man/Serializer-class.Rd dbdbed489254ef7a30c323ae149a4c57 *man/Serializer-initialize.Rd 3e76e2de814bc2f862c41117c1a1546f *man/Statement-class.Rd 3b0fe3fa25d0668b77f07be526d51c28 *man/Statement-initialize.Rd 4e9c4f82303727ed12f59143d5320307 *man/Storage-class.Rd 7fe20afd517d819ddf8143d52bf5b195 *man/Storage-initialize.Rd 7f3bba25646091c2887ea5ffc8466163 *man/World-class.Rd 83492e6e58ac8b47cdc6649dcd820a69 *man/World-initialize.Rd 8097164cde5a1fd1954cfe54dcd25504 *man/addStatement.Rd b2c0c6a26c5d7f162ab2cdb1f5700725 *man/executeQuery.Rd 6258377906e32f6d7be31230aa5613f0 *man/freeModel.Rd f785780a98dba71aa3e6021628ea9a3e *man/freeParser.Rd 14df2fefafc3d9ba043d73a2b4fa862d *man/freeQuery.Rd 8b00937b0757bdabf5fad9688e3611ed *man/freeQueryResults.Rd 50a34e06f246261b6a78e80e82f7de17 *man/freeSerializer.Rd 3ed2c87908d90ba4c552b99134603a22 *man/freeStatement.Rd 0f252ffb8443a92ea315fb929cf7b33c *man/freeStorage.Rd 2f9fa2a945c6514b68937ae72c557cba *man/freeWorld.Rd c78b5e8ce5ef429708e404fcab1240ab *man/getBlankNodeId.Rd 68635c6ce58f27c828e4f0904283c9ec *man/getNodeType.Rd 55f8658dfb195d877b4c437af0453df0 *man/getNodeValue.Rd 23809531aee79253d1d8e821f1a63350 *man/getQueryResultsLimit.Rd b9cfaae833f04b638e88d67a32964f8f *man/getResults.Rd 4ce9d5cc84c539b324cf4776b98c7015 *man/getTermType.Rd cef20d1c35c357463d68a8daea4834d8 *man/is.null.externalptr.Rd dda71d868c919ca7e1067703978c3972 *man/length-SWIGArray-method.Rd 27823d8b193581f02ffa3257736c61ce *man/librdf_copyright_string.Rd 77e2391906e6027ea714d3c85665e8a8 *man/librdf_copyright_string_get.Rd 69837c4cae07c46de3445f9303e1c98e *man/librdf_digest_final.Rd 3817ce3da32ba4ce4d129f9030f7f123 *man/librdf_digest_init.Rd 3df815130c2b5f95398eb299e9303584 *man/librdf_digest_to_string.Rd fc4ab712867422697ee717911370d1b1 *man/librdf_digest_update.Rd 850c6443df0c0edeef9ddea4a80e3aaf *man/librdf_digest_update_string.Rd a8fd931ebd526e3251fc09ba1df1f390 *man/librdf_free_digest.Rd dc913485d90762d51fcb7d4e3608d68b *man/librdf_free_hash.Rd c4b9942bf17685a180924127e7cfda15 *man/librdf_free_iterator.Rd e6a27d014827d5304879303db0c2cce7 *man/librdf_free_model.Rd 679f76fff267b21d044a52f7bb886d0e *man/librdf_free_node.Rd 8d943408c301fd3459b644a454034f63 *man/librdf_free_parser.Rd 3fc66358aa67d944b373e64985454e84 *man/librdf_free_query.Rd 671c5e31a91a141539d80a0cb4186e5b *man/librdf_free_query_results.Rd 178c299af90dc8e2007974a182c760a0 *man/librdf_free_serializer.Rd 42a5f41994e365955bf81cb9c73b4740 *man/librdf_free_statement.Rd 6bdf3cd0277c7908ea0866e72c4976e9 *man/librdf_free_storage.Rd 77f6fcd33c0686c0b42370338656e9da *man/librdf_free_stream.Rd 266572c14a80b7ae87e31f221aebbaa6 *man/librdf_free_uri.Rd 88543b8b15b5dcf258068e7768182618 *man/librdf_free_world.Rd e5149d367d2d80440056cf85779697ed *man/librdf_hash_to_string.Rd 90fcb7d73e7251d52ceb0165b6a238c7 *man/librdf_internal_test_error.Rd 7a894fc3bb8a70ce3dc20e0bf3da9921 *man/librdf_internal_test_warning.Rd c53941e2b23a29691a0fa043d665c9a0 *man/librdf_iterator_end.Rd 03407d8382d9aee26e82845a9f844aff *man/librdf_iterator_get_context.Rd f8479086b6d51d23939a55d8b2c265f2 *man/librdf_iterator_get_object.Rd ed5642216a08c8ee3e943b85a2717776 *man/librdf_iterator_next.Rd d6c6a131dbd270fce63c188711fe4e5a *man/librdf_log_message_code.Rd ca72f340eb3d00228a9639006ad496d4 *man/librdf_log_message_facility.Rd 4a62d420b210d334704e1f3efc46667d *man/librdf_log_message_level.Rd 3900b5f31ca89b4e580eee56fac639e1 *man/librdf_log_message_locator.Rd 3a6998e45a28401079bc972c874798f8 *man/librdf_log_message_message.Rd 64619b6647f9a25e29b35da3bd41d87d *man/librdf_model_add.Rd d17a327ecbf605cbc781f173e9080b53 *man/librdf_model_add_statement.Rd 0260bd66acfe98240a2cc51974fb6200 *man/librdf_model_add_statements.Rd a51b3e26d4ed35e0704a84a56390484d *man/librdf_model_add_string_literal_statement.Rd 4e040948138b702817bb643c997fbf8a *man/librdf_model_add_typed_literal_statement.Rd 535aea8873be3549432ff3d397044982 *man/librdf_model_as_stream.Rd f74679f1186c0d34b030eba59ccf41dc *man/librdf_model_contains_context.Rd 60a9a51fc41918dcac619807d3de444f *man/librdf_model_contains_statement.Rd 21614232eab1fef7f0f5be32daae4a6f *man/librdf_model_context_add_statement.Rd 83130eb2fc957cf83414e14fb19539b7 *man/librdf_model_context_add_statements.Rd 2dc5b75091f70a07cedb78513963f740 *man/librdf_model_context_as_stream.Rd 15e2d16d167dc2efb94eeadce2e10968 *man/librdf_model_context_remove_statement.Rd efbe90d5d643ce62eec9d31a38b47407 *man/librdf_model_context_remove_statements.Rd a43d274b010eed7d736182893b5151ef *man/librdf_model_find_statements.Rd d768b463a7ae013d6418bfc111da3545 *man/librdf_model_find_statements_in_context.Rd da2547a65a0bbf9624b5e7ea59312f32 *man/librdf_model_get_arc.Rd bdb8de01b1544b0cf36b5477133f4486 *man/librdf_model_get_arcs.Rd 8253b0d4eb764d7a19b3a537cc4a43b9 *man/librdf_model_get_arcs_in.Rd 58bcb425188ec5c5ae9f79b1125a5690 *man/librdf_model_get_arcs_out.Rd 5336995ce5faa8515da17269a93c4818 *man/librdf_model_get_contexts.Rd 884ac0c32b53b4c3c17059b0bde7556e *man/librdf_model_get_feature.Rd 46b444b9296a0c27c42b55e33642f98d *man/librdf_model_get_source.Rd 39d3c4f5d9045af78b835cf7e85ae5b9 *man/librdf_model_get_sources.Rd ad1c4252ca912bf05297ae8e3b75922b *man/librdf_model_get_target.Rd 22be859490f59ea79adccf2428b65a03 *man/librdf_model_get_targets.Rd c4e192f2cc9d5da9db43cfaafe7e8906 *man/librdf_model_has_arc_in.Rd 3875b6c7903b6b5d58d84e76ed2075da *man/librdf_model_has_arc_out.Rd 48126241e5bac808a748920d9f3361a6 *man/librdf_model_load.Rd 11cc316ffb181caa706a48821f1a7be2 *man/librdf_model_query_execute.Rd e1b12d674ace3bb5f45fc4c685e979bd *man/librdf_model_remove_statement.Rd 0c6fcc58b7230ea77728b073173e5c9e *man/librdf_model_set_feature.Rd 367e0d4312d08efcc9e8606e03fb38f6 *man/librdf_model_size.Rd 00811eb7f3775c9157c859445cef8c53 *man/librdf_model_sync.Rd 0dffa1e99d76c7c117c6d7be0a204510 *man/librdf_model_to_string.Rd 8b91c7d953e2c655bb2edda546742edd *man/librdf_model_transaction_commit.Rd 501975cf62050d4104595c681fe8ecc1 *man/librdf_model_transaction_rollback.Rd 529229ff663b8d3d5ea5cac2e14505ab *man/librdf_model_transaction_start.Rd 32aa9399026d5ef8aed6ea9a44bcd368 *man/librdf_new_digest.Rd 04e65c8f2b3d9e737afcd7ca0386f7c4 *man/librdf_new_hash.Rd 6ef632a0a821e1eaebf1fa281c0e39f5 *man/librdf_new_hash_from_array_of_strings.Rd 7ad368ccca2412628ead48c2a49a7c4e *man/librdf_new_hash_from_string.Rd 493927a2aea800424013689952eda622 *man/librdf_new_model.Rd 96cab4fb8d38ee9f7bde9eff235a9e42 *man/librdf_new_model_from_model.Rd c76d97e951b225bba6489d50c4dbb3da *man/librdf_new_model_with_options.Rd 50f0caaad4e950325ffaa75b807254f7 *man/librdf_new_node.Rd 5f4d0acc640d918c8648e8aaedbce10c *man/librdf_new_node_from_blank_identifier.Rd c54c5d70c223eac9390ee60006472908 *man/librdf_new_node_from_literal.Rd 93c99ed50a5e82cd0c9dfc6f22f34ad3 *man/librdf_new_node_from_node.Rd 3d35be7e092babb920589b7a0d4c04c3 *man/librdf_new_node_from_normalised_uri_string.Rd 8f75c10bc5c817e3d071d8b6b8517b05 *man/librdf_new_node_from_typed_literal.Rd c83fcbeb9c3a38651752ac63550c6854 *man/librdf_new_node_from_uri.Rd a8ef5f73596ac28075fdeaeb3d41e049 *man/librdf_new_node_from_uri_local_name.Rd a65c047d336d7fe2e2fc17a4c38b55a2 *man/librdf_new_node_from_uri_string.Rd 51cb68f7caf942c364571849baf6d798 *man/librdf_new_parser.Rd 1ae0f2a3e00db9578f934e4641e07c1a *man/librdf_new_query.Rd b7e09eaa8aa945ce662a6448ebec82bd *man/librdf_new_query_from_query.Rd e334d5188eeed204e9bace5628222afe *man/librdf_new_serializer.Rd a369dcd3d4de78c0fdbdb9b6f21b9ce9 *man/librdf_new_statement.Rd 596fa2a89a7c621537558ccd54e3f4a5 *man/librdf_new_statement_from_nodes.Rd 2ff284fc5dcbd84bbdd6a49c04e29674 *man/librdf_new_statement_from_statement.Rd 118030488ebcfc088f57872190019542 *man/librdf_new_storage.Rd 98132b621d59f155795d9dce8ed1232c *man/librdf_new_storage_from_storage.Rd 759d4a95153b5caf630546d818ce8a0f *man/librdf_new_uri.Rd 3b225b2f7208061d4f2d0764b11de753 *man/librdf_new_uri_from_filename.Rd ca4eca5a7213a1f3033044ab5bc31628 *man/librdf_new_uri_from_uri.Rd a6ee4121a525889021e0584b9a711b7e *man/librdf_new_world.Rd 6211e6c954dd34c32254a824b5c63d34 *man/librdf_node_equals.Rd 76e68443e08fc8882df0c66e0f539bb7 *man/librdf_node_get_blank_identifier.Rd ff433ed5d86a7d989d92e062e9ca36bb *man/librdf_node_get_li_ordinal.Rd 3694a3393086bf0b15162dfd9cfc6b8f *man/librdf_node_get_literal_value.Rd 80b9580903cdec0ef302bbc582806ebb *man/librdf_node_get_literal_value_as_latin1.Rd 563baa01984c7bae5832100f4dea5bb7 *man/librdf_node_get_literal_value_datatype_uri.Rd 706c1b66117591a381e4de474e3ed8f7 *man/librdf_node_get_literal_value_is_wf_xml.Rd 4baf20ecec395d677e4fc1f1de168fce *man/librdf_node_get_literal_value_language.Rd f1ff11b233a33d35ceb01046adccee38 *man/librdf_node_get_type.Rd 65f4267d9a4ffe3521e2140183222315 *man/librdf_node_get_uri.Rd 407e7cb92232d2e9fa2f6c637ae76be7 *man/librdf_node_is_blank.Rd 68730e281d0c72337f5a2c0ab7ec4c67 *man/librdf_node_is_literal.Rd af839a5bba03dc4fc72684b422ec4b68 *man/librdf_node_is_resource.Rd f4890a59ae43aa2a5328e7e4c6b7415e *man/librdf_parser_check_name.Rd 7afd891f395f3fce086681b8d22b4ef1 *man/librdf_parser_get_accept_header.Rd 5823aa0721c35f7d45665df0355bbcd7 *man/librdf_parser_get_feature.Rd 69518bb650831ca0d22b610f90142d6e *man/librdf_parser_get_namespaces_seen_count.Rd 7698563d5496e645f792910e8b9719d0 *man/librdf_parser_get_namespaces_seen_prefix.Rd 0124f5830a8a8b0721a9f59e0e6224eb *man/librdf_parser_get_namespaces_seen_uri.Rd 0e64b648d4a9b75bfc2285047330206a *man/librdf_parser_guess_name2.Rd 72ceeeab1e6a5ce6be0db2096d0c5c6d *man/librdf_parser_parse_as_stream.Rd 43409196c297ce910d061225514f99f6 *man/librdf_parser_parse_counted_string_as_stream.Rd f9a32e3a29483f9a007f040bdadea024 *man/librdf_parser_parse_counted_string_into_model.Rd 3cf0f0b19c48a5ed7186e8267f248c43 *man/librdf_parser_parse_into_model.Rd d6512cfb1064c96507c897e1a6e09dd7 *man/librdf_parser_parse_string_as_stream.Rd a6015f55e958372447b5064eb1ceb214 *man/librdf_parser_parse_string_into_model.Rd 026d702f046fb89cc7a8cbaa4fa105a6 *man/librdf_parser_set_feature.Rd bc8beeb3958f605f314af6a61d229d70 *man/librdf_query_execute.Rd 2266929b000c2df8d70f901440cf4319 *man/librdf_query_get_limit.Rd 2695125b932ba29c40a8b430c1dde08e *man/librdf_query_get_offset.Rd f2254f00344f48c6590119df1eacd0f6 *man/librdf_query_results_as_stream.Rd 618a92c2fab85ff0d80853bac91983ac *man/librdf_query_results_finished.Rd 155773665c6eb77011837241b40b3a06 *man/librdf_query_results_get_binding_name.Rd 1b978b6ecc89a095051ac48f91fef06d *man/librdf_query_results_get_binding_value.Rd 22bb01923d01d0d4581abe5386d474ad *man/librdf_query_results_get_binding_value_by_name.Rd ddb5f182bf058c27169ed9386d6ab46d *man/librdf_query_results_get_bindings_count.Rd 1249f57a2d3d1131c04f63b9d1f1d530 *man/librdf_query_results_get_boolean.Rd 1a219108eb8dfa000d20d0d310dc2f80 *man/librdf_query_results_get_count.Rd f35fefe76c25920f0f376e02472bd41d *man/librdf_query_results_is_bindings.Rd 053bdbfd36ee15b488c8007fc4b80fe1 *man/librdf_query_results_is_boolean.Rd a3d061068164994cead4b361aad0d739 *man/librdf_query_results_is_graph.Rd a8873bd30c9e41ead69d19ffb5744c0d *man/librdf_query_results_is_syntax.Rd fae3267d2528a753daef55020acc8f7b *man/librdf_query_results_next.Rd c9e7d8ed92fa186aafcbbfe40ad64164 *man/librdf_query_results_to_file2.Rd df092b57317d0d42d0d92f8058fe0533 *man/librdf_query_results_to_string2.Rd ebebb31b088ec8388fd9f98df48d7bc2 *man/librdf_query_set_limit.Rd ae4d97477c929b62471df7cd701b7187 *man/librdf_query_set_offset.Rd 61cc46a80f0556e3a5d1a2050a96888e *man/librdf_serializer_check_name.Rd 70aeb42256b80740e6762e8a39f7699e *man/librdf_serializer_get_feature.Rd d12bac673b7459846f82df45f74cbda2 *man/librdf_serializer_serialize_model_to_file.Rd 2f9c3fb52da64759ccf0a76cd65cc820 *man/librdf_serializer_serialize_model_to_string.Rd e31c1ef266bbf6ab85724c6ee19636b9 *man/librdf_serializer_serialize_stream_to_file.Rd 8dd232f350323901c6744957e75b1063 *man/librdf_serializer_serialize_stream_to_string.Rd f10fa9abae4178604db23187167c559f *man/librdf_serializer_set_feature.Rd 176a670ed3ad17aa1bd8eca206635264 *man/librdf_serializer_set_namespace.Rd 6b6340016ca029c313440db7c9649124 *man/librdf_short_copyright_string.Rd 5841785958152bcbcc6e66e6f570e7c0 *man/librdf_short_copyright_string_get.Rd 1309959ec9d0b641bcbd2528e4027617 *man/librdf_statement_equals.Rd a4f625126ce272f8336d89d01984f92d *man/librdf_statement_get_object.Rd 7c09c8eecf168649141a753c66932b9d *man/librdf_statement_get_predicate.Rd 22a2f04006e2a3d2f39a09fd7872a53d *man/librdf_statement_get_subject.Rd b458d35a327475b122b52f97bd33261b *man/librdf_statement_is_complete.Rd 1b08e30be8443e15ae920256c260f549 *man/librdf_statement_match.Rd 9c388c76f86558f04636c27ca1eaf133 *man/librdf_statement_set_object.Rd 167d56c840ce31a3db2c3192d5abf69e *man/librdf_statement_set_predicate.Rd 70b349f07a46c22f9a17861d79434e1b *man/librdf_statement_set_subject.Rd cdb4578efeb9558bb7dc1d40efcab9fb *man/librdf_stream_end.Rd 49dfc113ffbb2fa94b3669210116a7a0 *man/librdf_stream_get_object.Rd 90d7e6aa3e524a0045381746bba7832e *man/librdf_stream_next.Rd c0970006854b196b3496b381c77a8f95 *man/librdf_uri_compare.Rd 7197d96825885525eec3ad995e93fe01 *man/librdf_uri_equals.Rd 08ef3b84a8a93f860f77cd5aace83c2d *man/librdf_uri_to_string.Rd fa3408f898fecd4f217034828fb80fe7 *man/librdf_version_decimal.Rd 39e427be9e4652aba65a0495556808c0 *man/librdf_version_decimal_get.Rd 9a7b941c33becc4f46569f84b7da9d2d *man/librdf_version_major.Rd 6850708972a8daa1b1a790aea8ab58ad *man/librdf_version_major_get.Rd f0526dbc493e8b11ebf05d4e2c2ee250 *man/librdf_version_minor.Rd a35dfededd9fd7f5655043833c046cc2 *man/librdf_version_minor_get.Rd 393e70eb2f6d07e50d881068cd264bfb *man/librdf_version_release.Rd 1bde90dbc4e96cf4ce8b57adc508c289 *man/librdf_version_release_get.Rd 855e565eef73e84081f22c341c8185b1 *man/librdf_version_string.Rd 63ddcd2ad45b2975010b3422dab8ae1b *man/librdf_version_string_get.Rd 1c75a985923bafd7a8a43ea299ba1c82 *man/librdf_world_get_feature.Rd c437117a61566e68083961e4ee740c98 *man/librdf_world_open.Rd d06c9d0e222c3380618cd9dd31a9bc3b *man/librdf_world_set_feature.Rd da8f04cd8bf0b5795d2e4fb7ed06ec32 *man/librdf_world_set_logger.Rd 8d961b96a28e43c920e1f2098ca086d1 *man/mergeNamespace_roclet.Rd 93bad5888b9a3f8b1f0b20dedf775713 *man/parseFileIntoModel.Rd f16d6a3c6a492c6a9a4185d9115d3419 *man/raptor_locator_byte.Rd d82b38c12c18ce9068a1f21278a26553 *man/raptor_locator_column.Rd 95fba63e769761efaaaf5782044c86eb *man/raptor_locator_file.Rd 0f9c7c2b09aacf3967449ccb4c2365fc *man/raptor_locator_line.Rd 6163aa24814f6a39fd87e14aac24137b *man/raptor_locator_uri.Rd 6bbf004e9d1f8930bfa3efb980cfa1f8 *man/raptor_version_decimal.Rd 8d8d590648ecebf2072a0307dacdf4c0 *man/raptor_version_decimal_get.Rd 244ff919c8dd346c7fc0439dd29f7a31 *man/raptor_version_major.Rd 5b94078a8c97f25cef964ff41ff3016f *man/raptor_version_major_get.Rd 20691bca211aa06e9e8bda31efd3bf12 *man/raptor_version_minor.Rd 8df675fc7819f91283f61e7f652d3a96 *man/raptor_version_minor_get.Rd 5aead0bbd9e32adc9ebbc559aad4af4d *man/raptor_version_release.Rd 931c5d9caf7f558d98fd59400aa19657 *man/raptor_version_release_get.Rd 182fab9e82c0e346be894c5f03aa6e4c *man/raptor_version_string.Rd d14f9708951e61669d9516c0909cab55 *man/raptor_version_string_get.Rd bbc30054db9411d369879d5be48fb91a *man/rasqal_version_decimal.Rd 491b0148e4896ff4b0f191bd946e810a *man/rasqal_version_decimal_get.Rd d76e33ef0dbe373d1f72d73d12efddc7 *man/rasqal_version_major.Rd 1e299bc6984e9dd89195bba4da033e7a *man/rasqal_version_major_get.Rd b697b44c5e7e45668d94522c887ea6da *man/rasqal_version_minor.Rd 18be54965a4b210978cae28d73643472 *man/rasqal_version_minor_get.Rd 60fc28add00093ff87f2a03d7ae8ef29 *man/rasqal_version_release.Rd 3248323dde45103344399448ee236a48 *man/rasqal_version_release_get.Rd ed61baf93dc724d39611f8e1150f3f4f *man/rasqal_version_string.Rd fa05bcd49c960c35d2250237409a43e7 *man/rasqal_version_string_get.Rd f05342539b24b6c13f8579dc0189cfc1 *man/redland.Rd 5b8bba405cdfbd422513345815294280 *man/roclet_output.roclet_mergeNamespace.Rd 5baf74c67801c25482a8eb9ad953cbcb *man/roclet_process.roclet_mergeNamespace.Rd 81f9c1a02e0ffcd4d603d3342a44f655 *man/serializeToCharacter.Rd 70ec1c0e78b10f29d41dd80f5dfb6334 *man/serializeToFile.Rd 053a4235d22dba6934c22c93ae4ba74e *man/setNameSpace.Rd 192b20eba6390fda13d0ff01e3dc07e7 *man/setQueryResultsLimit.Rd 36bd4afd0a3a7f882f5b13eefe9c0904 *man/sub-ExternalReference-method.Rd f9745a146d8f14264c226d6537388292 *man/subset-ExternalReference-method.Rd 0c6e5e41f80b21cf981ef7c91969b377 *man/writeResults.Rd 06dae6c554fc448dfe0e4ff0566e6415 *src/Makevars.in f965eb4b0b640b6b5a0c99e07d432dc6 *src/Makevars.ucrt 66fd039a7e2c114bb56c95cd60a33316 *src/Makevars.win 452825cdc1d28bed321bec427ecb19e0 *src/redland.c 748492c77d626604f4ebda4f8862db9c *src/util.c 78a7f421feb7208c58c9197ba4eb5edb *tests/spelling.R 4d2de501fe63927667fc4eaaacc99a38 *tests/test-all.R 404f269341d605437989c05b16c47fcd *tests/testthat/test.Model.R 21f16cd94de11c63bed0b813f71da7e9 *tests/testthat/test.Node.R 649010532f837abe10a267cc865a74ea *tests/testthat/test.Parser.R 2a1a0da0f5bd985eaade56a5d6b53682 *tests/testthat/test.Query.R deefbc20746fee21356a40997326baf3 *tests/testthat/test.Serializer.R 98992754b40848a5ab18ced153b6bbd8 *tests/testthat/test.Statement.R 85506d9cc664197016d82eb3592861b3 *tests/testthat/test.Storage.R ec956a6da308aa766d8ce98c8244dc56 *tests/testthat/test.World.R 50274ae3adebc2b57bc59e634d6968d2 *tests/testthat/test.redland_base.R 8774f6190cbab3a52c848c5e53e3d7c4 *tools/Makefile d41d8cd98f00b204e9800998ecf8427e *tools/NEWS d41d8cd98f00b204e9800998ecf8427e *tools/README cec32a61c84eb6e749e480d8b5688b63 *tools/aclocal.m4 17ac9b8c7d402d7acae27f30bc8e0eda *tools/config.log 9a6e97777346f9869077e02fde81bf13 *tools/config.status 7485f7296b6c79676f46873d59987cf3 *tools/winlibs.R 3499da88a7682576ca0b95a0ad2b3703 *vignettes/redland_overview.Rmd redland/configure.win0000644000176200001440000000000012654540057014361 0ustar liggesusersredland/R/0000755000176200001440000000000015114710677012075 5ustar liggesusersredland/R/Node.R0000644000176200001440000002317314566244056013116 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' @title A Redland Node, used to store one node in an RDF triple statement. #' @description A Node represents a RDF Resource, Property, Literal or an RDF blank Node. #' @slot librdf_node A redland node object #' @include redland.R #' @include World.R #' @rdname Node-class #' @encoding UTF-8 #' @aliases Node #' @keywords classes #' @export #' @section Methods: #' \itemize{ #' \code{\link{Node-initialize}}: Initialize a Node object. #' \code{\link{getNodeType}}: Determine the node type and return as a string. #' \code{\link{getNodeValue}}: Determine the node type and return as a string. #' \code{\link{getBlankNodeId}}: Get the value of the node as a string. #' } #' @seealso \code{\link{redland}}: redland package #' @examples #' world <- new("World") #' # a blank node is created with a unique identifier generated by librdf #' node <- new("Node", world) #' # a blank node is created with a unique identifier generated by librdf #' node <- new("Node", world, blank=NULL) #' # a blank node is created with the user specified identifier, i.e. "_:id1" #' node <- new("Node", world, blank="someid") #' # a node type of 'literal' is created #' node <- new("Node", world, literal="A Node Value") #' # a Node type of 'resource' is created #' node <- new("Node", world, uri="http://www.example.com") #' # Create a literal node, specifying a language encoding #' node <- new("Node", world, literal="Gérard de La Martinière", language="fr") setClass("Node", slots = c(librdf_node = "_p_librdf_node_s")) #' Initialize a Node object. #' @description A Node has an associated type corresponding to the RDF component that it is representing. The list of possible #' types is "resource", "literal" or "blank". #' @details The url=' and 'literal=' arguments determine which type of Node is created. The Node type affects how the Node is processed #' in serialization, for example a Node created with 'node1 <- new("Node", literal="http://www.example.com")' is processed #' differently that a Node created with 'node1 <- new("Node", url="http://www.example.com")', with the former being processed #' as an RDF literal and the latter processed as an RDF resource. #' @rdname Node-initialize #' @aliases Node-initialize #' @param .Object the Node object to be initialized #' @param world a World object #' @param literal a literal character value to be assigned to the node #' @param uri a uri character value to be assigned to the node #' @param blank a blank node identifier to be assigned to the node #' @param datatype_uri a uri used to specify the datatype of a literal node, i.e. "http://www.w3.org/2001/XMLSchema#string" #' @param language a character value specifying the RDF language tag (excluding the "@" symbol), i.e. "fr" #' @note Refer to https://www.w3.org/TR/rdf11-concepts information on language tags. #' @return the Node object #' @export setMethod("initialize", signature = "Node", definition = function(.Object, world, literal, uri, blank, datatype_uri, language) { stopifnot(!is.null(world)) # Neither 'literal' nor 'uri', nor 'blank' was specified, so create a blank node with librdf generated id if(missing(literal) && missing(uri) && missing(blank)) { .Object@librdf_node <- librdf_new_node(world@librdf_world) } else if (!missing(uri)) { # 'uri=' was specified librdf_uri <- librdf_new_uri(world@librdf_world, uri) .Object@librdf_node <- librdf_new_node_from_uri(world@librdf_world, librdf_uri) } else if (!missing(literal)) { # a literal value was specified, but a blank value is not valid if(missing(language)) language="" # No default for language, so if not specified, set to blank #if(!grepl(language, "@")) language <- sprintf("@%s", language) if(literal == "") { stop(sprintf("Invalid value specified for Node type of literal: \"%s\"", literal)) } else { if (missing(datatype_uri)) { .Object@librdf_node <- librdf_new_node_from_literal(world@librdf_world, literal, language, 0) } else { # The datatype_uri specifies the RDF type to be associated with this node # and can only be applied to a literal value, therefor only to an object node # that has a literal value. When a statement with such a node is serialize to RDF/XML, the # rdf type is serialized as an XML attribute, i.e. for the literal node "John Smith" below # the datatype is an xsd:string: # # # John Smith # # type_uri <- librdf_new_uri(world@librdf_world, datatype_uri) .Object@librdf_node <- librdf_new_node_from_typed_literal(world@librdf_world, literal, language, type_uri) } } } else if (!missing(blank)) { # Create a blank node with a librdf generated unique identifier if(is.null(blank) || blank == "") { .Object@librdf_node <- librdf_new_node(world@librdf_world) } else { # Create a blank node with a user specified identifier .Object@librdf_node <- librdf_new_node_from_blank_identifier(world@librdf_world, blank) } } else { # If not creating a blank node, either 'literal' or 'uri' must be specified stop("Please specify either 'literal=\"value\"', 'uri=\"value\"' or 'blank=\"value\"'") } return(.Object) }) #' Determine the node type and return as a string #' @description A Node has a type that is assigned at initialization and can have one of the following values: #' 'resource', 'literal', 'blank' and 'unknown'. #' @rdname getNodeType #' @param .Object a Node object #' @return a character vector containing the Node type #' @examples #' world <- new("World") #' node <- new("Node", world, uri="http://www.example.com") #' nodeType <- getNodeType(node) #' @export setGeneric("getNodeType", function(.Object) { standardGeneric("getNodeType") }) #' @rdname getNodeType setMethod("getNodeType", signature("Node"), function(.Object) { if(librdf_node_is_resource(.Object@librdf_node)) { return("resource") } else if (librdf_node_is_literal(.Object@librdf_node)) { return("literal") } else if (librdf_node_is_blank(.Object@librdf_node)) { return("blank") } else { return("unknown") } }) #' Get the blank identifier that has been assigned for a specified Node object #' @details When a Node object is initialized with no value specified, i.e. node <- Node(""), #' a blank node is created and a locally unique identifier is generated by librdf. This method #' retrieves this identifier and returns in to the caller. #' @rdname getBlankNodeId #' @param .Object a Node object #' @return a blank node identifier #' @examples #' world <- new("World") #' # a blank node is created with a unique identifier generated by librdf #' node <- new("Node", world, blank=NULL) #' nodeId <- getBlankNodeId(node) #' @export setGeneric("getBlankNodeId", function(.Object) { standardGeneric("getBlankNodeId") }) #' @rdname getBlankNodeId setMethod("getBlankNodeId", signature("Node"), function(.Object) { if(librdf_node_is_blank(.Object@librdf_node)) { return(librdf_node_get_blank_identifier(.Object@librdf_node)) } else { return(as.character(NA)) } }) #' Get the value of the node as a string #' @details The value of the node is returned as a string. If the node type is #' 'blank', then the blank node identifier is returned. If the node type is #' 'literal', then the literal value is returned with the form "string@language, #' e.g. "¡Hola, amigo! ¿Cómo estás?"@es". If the node type is 'uri' #' then the value is returned as a string. #' @rdname getNodeValue #' @encoding UTF-8 #' @param .Object a Node object #' @return a string representation of the Node's value #' @examples #' world <- new("World") #' node <- new("Node", world, literal="¡Hola, amigo! ¿Cómo estás?", language="es") #' value <- getNodeValue(node) #' @export setGeneric("getNodeValue", function(.Object) { standardGeneric("getNodeValue") }) #' @rdname getNodeValue setMethod("getNodeValue", signature("Node"), function(.Object) { if(librdf_node_is_resource(.Object@librdf_node)) { librdf_uri <- librdf_node_get_uri(.Object@librdf_node) val <- librdf_uri_to_string(librdf_uri) librdf_free_uri(librdf_uri) return(val) } else if (librdf_node_is_literal(.Object@librdf_node)) { val <- librdf_node_get_literal_value(.Object@librdf_node) lang <- librdf_node_get_literal_value_language(.Object@librdf_node) # If the node has a language tag defined, then include it, otherwise don't if(is.null(lang) || is.na(lang) || lang == "") { literal <- sprintf("%s", val) } else { literal <- sprintf("\"%s\"@%s\"", val, lang) } return(literal) } else if (librdf_node_is_blank(.Object@librdf_node)) { return(getBlankNodeId(.Object)) } else { stop("Node type unknown, cannot get the node value") } }) redland/R/QueryResults.R0000644000176200001440000000634514566244056014722 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' @title A Redland QueryResults object is used to inspect query results from a Query object. #' @description The QueryResults object contains the RDF statements that were returned from #' a query on an RDF model. #' @slot librdf_query_results A redland query object #' @rdname QueryResults-class #' @aliases QueryResults #' @include redland.R #' @keywords classes #' @export #' @section Methods: #' \itemize{ #' \code{\link{QueryResults-initialize}}: Initialize a QueryResults object. #' \code{\link{freeQueryResults}}: Free memory used by a librdf query result. #' } #' @seealso \code{\link{redland}}: redland package setClass("QueryResults", slots = c(librdf_query_results = "_p_librdf_query_results")) #' Initialize the QueryResults object. #' @description The QueryResults object is initialized with the librdf query result from #' return value of \code{'Query.execute()'}. #' @details A QueryResults object is returned by the \code{Query.executeQuery()} method, so typically a user #' does not initialize a QueryResult object by calling \code{new("QueryResult", ...)} #' @rdname QueryResults-initialize #' @aliases QueryResults-initialize #' @param .Object the QueryResults object. #' @param results a librdf query result #' @return the QueryResults object #' @export setMethod("initialize", signature = "QueryResults", definition = function(.Object, results) { .Object@librdf_query_results <- results return(.Object) }) #' Free memory used by a librdf query results #' @description After this method is called, the QueryResults object is no longer usable and should #' be deleted with \code{"rm(query)"}. #' @rdname freeQueryResults #' @param .Object a QueryResults object #' @export setGeneric("freeQueryResults", function(.Object) { standardGeneric("freeQueryResults") }) #' @rdname freeQueryResults setMethod("freeQueryResults", signature("QueryResults"), function(.Object) { # Have to free all of the nodes that were created by the query result that # hold the bound node values if (!is.null(.Object@librdf_query_results) && librdf_query_results_finished(.Object@librdf_query_results) == 0) { num_nodes <- librdf_query_results_get_bindings_count(.Object@librdf_query_results) for (i in 1:num_nodes-1) { binding_name <- librdf_query_results_get_binding_name(.Object@librdf_query_results, i) val = librdf_query_results_get_binding_value(.Object@librdf_query_results, i) if (!is.null.externalptr(val@ref)) { librdf_free_node(val) } } } librdf_free_query_results(.Object@librdf_query_results) }) redland/R/Statement.R0000644000176200001440000002715014566244056014174 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' @title An RDF Statement object #' @slot librdf_statement A redland statement object #' @rdname Statement-class #' @aliases Statement #' @encoding UTF-8 #' @include redland.R #' @include World.R #' @include Node.R #' @keywords classes #' @export #' @description A Statement object is created using the provided subject, predicate and object. #' @details A Statement object can be created from Node objects that are provided for the subject, #' predicate and object. An alternative way to create a Statement object is to provide the #' subject, predicate and object as character values. If this later method is used, the character values will be evaluated to #' determine the appropriate RDF type for the subject and object. Note that the RDF type for the predicate will always #' be 'uri' (aka 'resource'). If the automatic determination of RDF types is not desired, then the \code{subjectType} and #' \code{objectType} parameters can be specified to explicitly set the RDF types. #' @section Methods: #' \itemize{ #' \code{\link{Statement-initialize}}: Initialize a Statement object. #' \code{\link{getTermType}}: Return the redland node type for the specified RDF term in a statement. #' \code{\link{freeStatement}}: Free memory used by a librdf statement. #' } #' @seealso \code{\link{redland}}: redland package #' @examples #' world <- new("World") #' # Create nodes manually and add to the statment #' subject <- new("Node", blank="_:myid1", world) #' predicate <- new("Node", uri="http://www.example.com/isa", world) #' object <- new("Node", literal="thing", world) #' stmt <- new("Statement", world, subject, predicate, object) #' #' # Create the statement specifying node values directly #' stmt <- new("Statement", world, subject="http://www.example.com/myevent", #' predicate="http://example.com/occurredAt", #' object="Tue Feb 17 14:05:13 PST 2015") #' stmt <- new("Statement", world, subject=NULL, #' predicate="http://www.example.com/hasAddr", #' object="http://www.nothing.com", objectType="literal") #' stmt <- new("Statement", world, subject="http://www.example.com/BobSmith", #' predicate="http://www.example.com/says", #' object="¡Hola, amigo! ¿Cómo estás?", #' objectType="literal", #' language="es") setClass("Statement", slots = c(librdf_statement = "_p_librdf_statement_s")) #' Construct a Statement object. #' @rdname Statement-initialize #' @aliases Statement-initialize #' @param .Object the Statement object #' @param world a World object #' @param subject a Node object #' @param predicate a Node object #' @param object a Node object #' @param subjectType the Node type of the subject, i.e. "blank", "uri" #' @param objectType the Node type of the object, i.e. "blank", "uri", "literal" #' @param datatype_uri the datatype URI to associate with a object literal value #' @param language a character value specifying the RDF language tag for an object literal value (excluding the "@" symbol), i.e. "fr" #' @return the Statement object #' @export setMethod("initialize", signature = "Statement", definition = function(.Object, world, subject, predicate, object, subjectType=as.character(NA), objectType=as.character(NA), datatype_uri=as.character(NA), language=as.character(NA)) { # Ensure that all provided params are not null stopifnot(!is.null(world), !missing(subject), !missing(predicate), !missing(object)) # The subject, predicate and object have all been passed in as characters, so we need to # evaluate them and create appropriate Node objects from them that will be used to # create the statement object. if ( (is.null(subject) || inherits(subject, "character")) && inherits(predicate, "character") && (is.null(object) || inherits(object, "character")) ) { # If subjectType was not specified, determine the subjectType by inspecting the # subject value if (is.na(subjectType)) { if (is.null(subject)) { subjectType <- "blank" } else if (length(grep("^_:", subject)) == 1) { subjectType <- "blank" } else if (subject == "") { subjectType <- "blank" } else { subjectType <- "uri" } } else if (subjectType != "uri" && subjectType != "blank") { stop(sprintf("Invalid value for subjectType: %s", subjectType)) } # Create the subject Node from the passed in character value, and the # node type that was either passed in or determined from the character value if (is.null(subject)) { subjectNode <- new("Node", world) } else if (subjectType == "blank") { subjectNode <- new("Node", world, blank=subject) } else if (subjectType == "uri") { subjectNode <- new("Node", world, uri=subject) } else { stop(sprintf("Invalid type for subject node: %s", subject)) } # The predicate is always a URI predicateNode <- new("Node", world, uri=predicate) # Determine the type of the object node from the passed in value if (is.na(objectType)) { if (is.null(object)) { objectType <- "blank" } else if (length(grep("^http:", object)) == 1) { objectType <- "uri" } else if (length(grep("^https:", object)) == 1) { objectType <- "uri" } else if (length(grep("^urn:", object)) == 1) { objectType <- "uri" } else if (length(grep("^_:", object)) == 1) { objectType <- "blank" } else if (object == "") { objectType <- "blank" } else if (is.null(object)) { objectType <- "blank" } else { objectType <- "literal" } } else if (objectType != "uri" && objectType != "literal" && objectType != "blank") { stop(sprintf("Invalid value for objectType: %s", objectType)) } # Create the object Node from the passed in character value, and the type # that was either passed in or determined from the argument value if (is.null(object)) { objectNode <- new("Node", world) } else if (objectType == "blank") { objectNode <- new("Node", world, blank=object) } else if (objectType == "uri") { objectNode <- new("Node", world, uri=object) } else { if(is.na(language)) language <- "" if(is.na(datatype_uri)) { objectNode <- new("Node", world, literal=object, language=language) } else { objectNode <- new("Node", world, literal=object, datatype_uri=datatype_uri, language=language) } } .Object@librdf_statement <- librdf_new_statement_from_nodes(world@librdf_world, subjectNode@librdf_node, predicateNode@librdf_node, objectNode@librdf_node); } else { # The subject, predicate and object have all been passed in as Node objects, so create # the statement from these objects directly. if (inherits(subject, "Node") && inherits(predicate, "Node") && inherits(object, "Node")) { # Create the underlying redland statement object .Object@librdf_statement <- librdf_new_statement_from_nodes(world@librdf_world, subject@librdf_node, predicate@librdf_node, object@librdf_node); } else { stop(sprintf("Invalid argument types for subject (%s), predicate(%s) or object(%s).", class(subject), class(predicate), class(object))) } } return(.Object) }) #' Return the redland node type for the specified RDF term in a statement #' @description After a Statement object has been created, this method can #' be used to determine the RDF type ("uri", "literal", "blank") that has been #' assigned to the specified RDF term, i.e. "subject", "predicate", "object". #' @rdname getTermType #' @param .Object a Statement object #' @param term the RDF term for which the type will be returned #' @export #' @examples #' world <- new("World") #' subject <- new("Node", blank="_:myid1", world) #' predicate <- new("Node", uri="http://www.example.com/isa", world) #' object <- new("Node", literal="thing", world) #' stmt <- new("Statement", world, subject, predicate, object, world) #' termType <- getTermType(stmt, "predicate") setGeneric("getTermType", function(.Object, term) { standardGeneric("getTermType") }) #' @rdname getTermType setMethod("getTermType", signature("Statement", "character"), function(.Object, term) { if (term != "subject" && term != "predicate" && term != "object") { stop("Must specify \"subject\", \"predicate\", or \"object\" for term") } # Retrieve a pointer to the specified node object from librdf if (term == "subject") { termPtr <- librdf_statement_get_subject(.Object@librdf_statement) } else if (term == "predicate") { termPtr <- librdf_statement_get_predicate(.Object@librdf_statement) } else { termPtr <- librdf_statement_get_object(.Object@librdf_statement) } # Print out the redland node type corresponding to the RDF term type for the specified term if(librdf_node_is_resource(termPtr)) { return("resource") } else if (librdf_node_is_literal(termPtr)) { return("literal") } else if (librdf_node_is_blank(termPtr)) { return("blank") } else { return("unknown") } }) #' Free memory used by a librdf statement #' @details After this method is called, the Statement object is no longer usable and should #' be deleted \code{"rm(statement)"} and a new object created. This method frees #' all resources for the statement, as well as each node in the statement. #' @rdname freeStatement #' @param .Object a Statement object #' @examples #' world <- new("World") #' stmt <- new("Statement", world, subject="http://www.example.com/myevent", #' predicate="http://example.com/occurredAt", #' object="Tue Feb 17 14:05:13 PST 2015") #' # At this point, some operations would be performed with the Statement. #' # See '?redland' for a complete example. #' # When the Statement object is no longer needed, the resources it had allocated can be freed. #' freeStatement(stmt) #' rm(stmt) #' @export setGeneric("freeStatement", function(.Object) { standardGeneric("freeStatement") }) #' @rdname freeStatement setMethod("freeStatement", signature("Statement"), function(.Object) { librdf_free_statement(.Object@librdf_statement) })redland/R/Storage.R0000644000176200001440000000616414566244056013636 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' A Redland Storage object #' @slot librdf_storage A redland storage object #' @slot type the storage type to create, i.e. "hashes", "mysql", "postgresql", ... #' @rdname Storage-class #' @aliases Storage #' @include redland.R #' @include World.R #' @keywords classes #' @section Methods: #' \itemize{ #' \code{\link{Storage-initialize}}: Initialize a Storage object #' \code{\link{freeStorage}}: Free memory used by a librdf storage object #' } #' @seealso \code{\link{redland}}: redland package #' @export #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") setClass("Storage", slots = c(librdf_storage = "_p_librdf_storage_s", type = "character" )) #' Initialize a Storage object #' @rdname Storage-initialize #' @aliases Storage-initialize #' @param .Object the Storage object #' @param world the World object #' @param type the Redland storage type #' @param name storage instance name #' @param options storage options #' @return the Storage object #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' @export setMethod("initialize", signature = "Storage", definition = function(.Object, world, type="hashes", name="", options="hash-type='memory'") { stopifnot(!is.null(world)) .Object@type <- type .Object@librdf_storage <- librdf_new_storage(world@librdf_world, type, name, options); #librdf_storage_open(.Object@librdf_storage) return(.Object) }) #' Free memory used by a librdf storage object #' @description After this method is called, the Storage object is no longer usable and should #' be deleted \code{"rm(storage)"} and a new object created. #' @rdname freeStorage #' @param .Object a Storage object to free memory for #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' # At this point we would perform some operations using the storage object. #' # See '?redland' for a complete example. #' # When the Storage object is no longer needed, the resources it had allocated can be freed. #' status <- freeStorage(storage) #' rm(storage) #' @export setGeneric("freeStorage", function(.Object) { standardGeneric("freeStorage") }) #' @rdname freeStorage setMethod("freeStorage", signature("Storage"), function(.Object) { librdf_free_storage(.Object@librdf_storage) })redland/R/redland-package.R0000644000176200001440000001210115114710677015215 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' @keywords internal "_PACKAGE" #' @title Create, query and write RDF graphs. #' @name redland #' @author Matthew B. Jones (NCEAS) and Peter Slaughter (NCEAS) #' @description The R package \emph{redland} provides methods to create, query and write information stored in the #' Resource Description Framework (RDF). This package is implemented as R scripts that provide an #' R interface (aka "wrapper") to the Redland RDF C libraries. Documentation for the redland R package classes #' and functions are available from the standard R help facility, for example, \code{'help("Node-class")'}, \code{'?getNodeType'}, etc. #' #' An overview of the redland R package is available with the R command: \code{'vignette("redland_overview")'}. #' #' The Redland C library functions are described at \url{https://librdf.org/docs/api/index.html}. #' #' An introduction to RDF can be found at \url{https://www.w3.org/TR/rdf-primer/}. #' #' @details #' The redland R package classes and the corresponding Redland C library types are shown in the following table: #' \tabular{llll}{ #' \strong{Concept}\tab \strong{Redland C type}\tab \strong{redland R class}\tab \strong{Purpose}\cr #' Resource / Literal\tab librdf_node\tab \linkS4class{Node}\tab RDF Model & Syntax nodes\cr #' Statement / Triple\tab librdf_statement\tab \linkS4class{Statement}\tab RDF Model & Syntax arcs (statements, triples)\cr #' Model\tab librdf_model\tab \linkS4class{Model}\tab Set of Statements usually held in one Storage.\cr #' Node\tab librdf_node\tab \linkS4class{Node}\tab The subject, predicate or object of a Statement\cr #' Storage\tab librdf_storage\tab \linkS4class{Storage}\tab Storage for Models either persistent or in-memory.\cr #' Parser\tab librdf_parser\tab \linkS4class{Parser}\tab Syntax parsers delivering Stream of Statements or writing to a Model\cr #' Query\tab librdf_query\tab \linkS4class{Query}\tab Querying of an Model delivering a QueryResults\cr #' QueryResults\tab librdf_query_results\tab \linkS4class{QueryResults}\tab Results of applying an Query to a Model giving either variable bindings with Node values or Stream of Statements\cr #' Serializer\tab librdf_serializer\tab \linkS4class{Serializer}\tab Serializes a Model into a syntax such as RDF/XML\cr #' World\tab librdf_world\tab \linkS4class{World}\tab RDF wrapper class handling Redland startup/shutdown\cr #' } #' #' @note #' In order to communicate with the Redland RDF C libraries, the redland R package uses an interface layer that is created #' with the software package \emph{Simplified Wrapper and Interface Generator} (\href{https://github.com/swig/swig}{SWIG}). #' The relationship between the redland R package and the Redland C libraries is: #' #' User script -> redland R package -> SWIG R interface -> Redland C libraries -> RDF data #' #' It is recommended that the redland package R classes be used to interact with RDF, as these higher level classes take care of many of the the #' details of communicating with the Redland C libraries. However, all of the lower level R interface functions generated by SWIG are made available #' by the redland package. These interface functions usually have names beginning with \code{'librdf_'}, \code{'rasqal_'} or \code{'raptor_'} and #' are usually the same name as the underlying C library function. Documentation #' for the R SWIG interface functions can be found via R help i.e. \code{'?librdf_iterator'}. #' #' @examples #' # This example creates the necessary R objects to hold an RDF model and reads #' # in a file that contains RDF/XML statements. This model is then queried for #' # and the query results inspected. #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' filePath <- system.file("extdata/example.rdf", package="redland") #' parser <- new("Parser", world) #' parseFileIntoModel(parser, world, filePath, model) #' queryString <- paste("PREFIX dc: ", #' "SELECT ?a ?c WHERE { ?a dc:description ?c . }", sep="") #' query <- new("Query", world, queryString, base_uri=NULL, #' query_language="sparql", query_uri=NULL) #' results <- getResults(query, model, "rdfxml") #' #' # When the query object is no longer needed, the resources it had allocated can be freed. #' freeQuery(query) #' rm(query) ## usethis namespace: start ## usethis namespace: end NULL redland/R/World.R0000644000176200001440000000475714566244056013327 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' @title A Redland World object, used to initialize the Redland RDF library. #' @description A World object is the top level object in the Redland RDF library #' implementation, so it contains all other objects needed to process RDF #' Models. #' @slot librdf_world A redland world object #' @aliases World #' @include redland.R #' @keywords classes #' @useDynLib redland, .registration = TRUE #' @section Methods: #' \itemize{ #' \code{\link{World-initialize}}: Initialize a World object #' \code{\link{freeWorld}}: Free memory used by a librdf world object #' } #' @seealso \code{\link{redland}}: redland package #' @examples #' world <- new("World") #' @import methods #' @export setClass("World", slots = c(librdf_world = "_p_librdf_world_s")) #' Initialize the World object. #' @rdname World-initialize #' @aliases World-initialize #' @param .Object the World object #' @return the World object #' @export setMethod("initialize", signature = "World", definition = function(.Object) { .Object@librdf_world <- librdf_new_world(); librdf_world_open(.Object@librdf_world) return(.Object) }) #' Free memory used by a librdf world object #' @details After this method is called, the World object is no longer usable and should #' be deleted \code{"rm(world)"} and a new object created. #' @rdname freeWorld #' @param .Object a World object #' @export #' @examples #' world <- new("World") #' # At this point we would perform some operations using the world object. #' # When the world object is no longer needed, we can free the resources it has allocated. #' result <- freeWorld(world) #' rm(world) setGeneric("freeWorld", function(.Object) { standardGeneric("freeWorld") }) #' @rdname freeWorld setMethod("freeWorld", signature("World"), function(.Object) { librdf_free_world(.Object@librdf_world) }) redland/R/redland.R0000644000176200001440000035526714566231413013647 0ustar liggesusers# This file was automatically generated by SWIG (https://www.swig.org). # Version 3.0.12 # # Do not make changes to this file unless you know what you are doing--modify # the SWIG interface file instead. ## Generated via the command line invocation: ## swig -r -namespace -v -I. -module redland -outdir redland/R -o redland/src/redland.c Redland.i # srun.swg # # # This is the basic code that is needed at run time within R to # provide and define the relevant classes. It is included # automatically in the generated code by copying the contents of # srun.swg into the newly created binding code. # This could be provided as a separate run-time library but this # approach allows the code to to be included directly into the # generated bindings and so removes the need to have and install an # additional library. We may however end up with multiple copies of # this and some confusion at run-time as to which class to use. This # is an issue when we use NAMESPACES as we may need to export certain # classes. ###################################################################### if(length(getClassDef("RSWIGStruct")) == 0) setClass("RSWIGStruct", representation("VIRTUAL")) if(length(getClassDef("ExternalReference")) == 0) # Should be virtual but this means it loses its slots currently #representation("VIRTUAL") setClass("ExternalReference", representation( ref = "externalptr")) if(length(getClassDef("NativeRoutinePointer")) == 0) setClass("NativeRoutinePointer", representation(parameterTypes = "character", returnType = "character", "VIRTUAL"), contains = "ExternalReference") if(length(getClassDef("CRoutinePointer")) == 0) setClass("CRoutinePointer", contains = "NativeRoutinePointer") if(length(getClassDef("EnumerationValue")) == 0) setClass("EnumerationValue", contains = "integer") if(!isGeneric("copyToR")) setGeneric("copyToR", function(value, obj = new(gsub("Ref$", "", class(value)))) standardGeneric("copyToR" )) setGeneric("delete", function(obj) standardGeneric("delete")) SWIG_createNewRef = function(className, ..., append = TRUE) { f = get(paste("new", className, sep = "_"), mode = "function") f(...) } if(!isGeneric("copyToC")) setGeneric("copyToC", function(value, obj = SWIG_createNewRef(class(value))) standardGeneric("copyToC" )) # defineEnumeration = function(name, .values, where = topenv(parent.frame()), suffix = "Value") { # Mirror the class definitions via the E analogous to .__C__ defName = paste(".__E__", name, sep = "") assign(defName, .values, envir = where) if(nchar(suffix)) name = paste(name, suffix, sep = "") setClass(name, contains = "EnumerationValue", where = where) } enumToInteger <- function(name,type) { if (is.character(name)) { ans <- as.integer(get(paste(".__E__", type, sep = ""))[name]) if (is.na(ans)) {warning("enum not found ", name, " ", type)} ans } } enumFromInteger = function(i,type) { itemlist <- get(paste(".__E__", type, sep="")) names(itemlist)[match(i, itemlist)] } coerceIfNotSubclass = function(obj, type) { if(!is(obj, type)) {as(obj, type)} else obj } setClass("SWIGArray", representation(dims = "integer"), contains = "ExternalReference") setMethod("length", "SWIGArray", function(x) x@dims[1]) defineEnumeration("SCopyReferences", .values = c( "FALSE" = 0, "TRUE" = 1, "DEEP" = 2)) assert = function(condition, message = "") { if(!condition) stop(message) TRUE } if(FALSE) { print.SWIGFunction = function(x, ...) { } } ####################################################################### R_SWIG_getCallbackFunctionStack = function() { # No PACKAGE argument as we don't know what the DLL is. .Call("R_SWIG_debug_getCallbackFunctionData") } R_SWIG_addCallbackFunctionStack = function(fun, userData = NULL) { # No PACKAGE argument as we don't know what the DLL is. .Call("R_SWIG_R_pushCallbackFunctionData", fun, userData) } ####################################################################### setClass('_p_librdf_world_s', contains = 'ExternalReference') setClass('_p_librdf_digest_s', contains = 'ExternalReference') setClass('_p_librdf_hash_s', contains = 'ExternalReference') setClass('_p_librdf_uri_s', contains = 'ExternalReference') setClass('_p_librdf_iterator_s', contains = 'ExternalReference') setClass('_p_librdf_node_s', contains = 'ExternalReference') setClass('_p_librdf_statement_s', contains = 'ExternalReference') setClass('_p_librdf_model_s', contains = 'ExternalReference') setClass('_p_librdf_storage_s', contains = 'ExternalReference') setClass('_p_librdf_stream_s', contains = 'ExternalReference') setClass('_p_librdf_parser_s', contains = 'ExternalReference') setClass('_p_librdf_serializer_s', contains = 'ExternalReference') setMethod('[', "ExternalReference", function(x,i,j, ..., drop=TRUE) if (!is.null(x$"__getitem__")) sapply(i, function(n) x$"__getitem__"(i=as.integer(n-1)))) setMethod('[<-' , "ExternalReference", function(x,i,j, ..., value) if (!is.null(x$"__setitem__")) { sapply(1:length(i), function(n) x$"__setitem__"(i=as.integer(i[n]-1), x=value[n])) x }) setAs('ExternalReference', 'character', function(from) {if (!is.null(from$"__str__")) from$"__str__"()}) suppressMessages(suppressWarnings(setMethod('print', 'ExternalReference', function(x) {print(as(x, "character"))}))) # Start of librdf_new_digest `librdf_new_digest` = function(world, name) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); ;ans = .Call('R_swig_librdf_new_digest', world, name, PACKAGE='redland'); ans <- new("_p_librdf_digest_s", ref=ans) ; ans } attr(`librdf_new_digest`, 'returnType') = '_p_librdf_digest_s' attr(`librdf_new_digest`, "inputTypes") = c('_p_librdf_world_s', 'character') class(`librdf_new_digest`) = c("SWIGFunction", class('librdf_new_digest')) # Start of librdf_free_digest `librdf_free_digest` = function(digest) { if (inherits(digest, "ExternalReference")) digest = slot(digest,"ref") ;.Call('R_swig_librdf_free_digest', digest, PACKAGE='redland'); } attr(`librdf_free_digest`, 'returnType') = 'void' attr(`librdf_free_digest`, "inputTypes") = c('_p_librdf_digest_s') class(`librdf_free_digest`) = c("SWIGFunction", class('librdf_free_digest')) # Start of librdf_digest_init `librdf_digest_init` = function(digest) { if (inherits(digest, "ExternalReference")) digest = slot(digest,"ref") ;.Call('R_swig_librdf_digest_init', digest, PACKAGE='redland'); } attr(`librdf_digest_init`, 'returnType') = 'void' attr(`librdf_digest_init`, "inputTypes") = c('_p_librdf_digest_s') class(`librdf_digest_init`) = c("SWIGFunction", class('librdf_digest_init')) # Start of librdf_digest_update `librdf_digest_update` = function(digest, buf, length) { if (inherits(digest, "ExternalReference")) digest = slot(digest,"ref") buf = as(buf, "character"); length = as.integer(length); if(length(length) > 1) { warning("using only the first element of length"); }; ;.Call('R_swig_librdf_digest_update', digest, buf, length, PACKAGE='redland'); } attr(`librdf_digest_update`, 'returnType') = 'void' attr(`librdf_digest_update`, "inputTypes") = c('_p_librdf_digest_s', 'character', 'integer') class(`librdf_digest_update`) = c("SWIGFunction", class('librdf_digest_update')) # Start of librdf_digest_update_string `librdf_digest_update_string` = function(digest, string) { if (inherits(digest, "ExternalReference")) digest = slot(digest,"ref") string = as(string, "character"); ;.Call('R_swig_librdf_digest_update_string', digest, string, PACKAGE='redland'); } attr(`librdf_digest_update_string`, 'returnType') = 'void' attr(`librdf_digest_update_string`, "inputTypes") = c('_p_librdf_digest_s', 'character') class(`librdf_digest_update_string`) = c("SWIGFunction", class('librdf_digest_update_string')) # Start of librdf_digest_final `librdf_digest_final` = function(digest) { if (inherits(digest, "ExternalReference")) digest = slot(digest,"ref") ;.Call('R_swig_librdf_digest_final', digest, PACKAGE='redland'); } attr(`librdf_digest_final`, 'returnType') = 'void' attr(`librdf_digest_final`, "inputTypes") = c('_p_librdf_digest_s') class(`librdf_digest_final`) = c("SWIGFunction", class('librdf_digest_final')) # Start of librdf_digest_to_string `librdf_digest_to_string` = function(digest) { if (inherits(digest, "ExternalReference")) digest = slot(digest,"ref") ;.Call('R_swig_librdf_digest_to_string', digest, PACKAGE='redland'); } attr(`librdf_digest_to_string`, 'returnType') = 'character' attr(`librdf_digest_to_string`, "inputTypes") = c('_p_librdf_digest_s') class(`librdf_digest_to_string`) = c("SWIGFunction", class('librdf_digest_to_string')) # Start of librdf_new_hash `librdf_new_hash` = function(world, name) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); ;ans = .Call('R_swig_librdf_new_hash', world, name, PACKAGE='redland'); ans <- new("_p_librdf_hash_s", ref=ans) ; ans } attr(`librdf_new_hash`, 'returnType') = '_p_librdf_hash_s' attr(`librdf_new_hash`, "inputTypes") = c('_p_librdf_world_s', 'character') class(`librdf_new_hash`) = c("SWIGFunction", class('librdf_new_hash')) # Start of librdf_new_hash_from_string `librdf_new_hash_from_string` = function(world, name, string) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); string = as(string, "character"); ;ans = .Call('R_swig_librdf_new_hash_from_string', world, name, string, PACKAGE='redland'); ans <- new("_p_librdf_hash_s", ref=ans) ; ans } attr(`librdf_new_hash_from_string`, 'returnType') = '_p_librdf_hash_s' attr(`librdf_new_hash_from_string`, "inputTypes") = c('_p_librdf_world_s', 'character', 'character') class(`librdf_new_hash_from_string`) = c("SWIGFunction", class('librdf_new_hash_from_string')) # Start of librdf_new_hash_from_array_of_strings `librdf_new_hash_from_array_of_strings` = function(world, name, string) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); if (inherits(string, "ExternalReference")) string = slot(string,"ref") ;ans = .Call('R_swig_librdf_new_hash_from_array_of_strings', world, name, string, PACKAGE='redland'); ans <- new("_p_librdf_hash_s", ref=ans) ; ans } attr(`librdf_new_hash_from_array_of_strings`, 'returnType') = '_p_librdf_hash_s' attr(`librdf_new_hash_from_array_of_strings`, "inputTypes") = c('_p_librdf_world_s', 'character', 'character') class(`librdf_new_hash_from_array_of_strings`) = c("SWIGFunction", class('librdf_new_hash_from_array_of_strings')) # Start of librdf_hash_to_string `librdf_hash_to_string` = function(hash, filter) { if (inherits(hash, "ExternalReference")) hash = slot(hash,"ref") if (inherits(filter, "ExternalReference")) filter = slot(filter,"ref") ;.Call('R_swig_librdf_hash_to_string', hash, filter, PACKAGE='redland'); } attr(`librdf_hash_to_string`, 'returnType') = 'character' attr(`librdf_hash_to_string`, "inputTypes") = c('_p_librdf_hash_s', '_p_p_char') class(`librdf_hash_to_string`) = c("SWIGFunction", class('librdf_hash_to_string')) # Start of librdf_free_hash `librdf_free_hash` = function(hash) { if (inherits(hash, "ExternalReference")) hash = slot(hash,"ref") ;.Call('R_swig_librdf_free_hash', hash, PACKAGE='redland'); } attr(`librdf_free_hash`, 'returnType') = 'void' attr(`librdf_free_hash`, "inputTypes") = c('_p_librdf_hash_s') class(`librdf_free_hash`) = c("SWIGFunction", class('librdf_free_hash')) # Start of librdf_new_world `librdf_new_world` = function() { ;ans = .Call('R_swig_librdf_new_world', PACKAGE='redland'); ans <- new("_p_librdf_world_s", ref=ans) ; ans } attr(`librdf_new_world`, 'returnType') = '_p_librdf_world_s' class(`librdf_new_world`) = c("SWIGFunction", class('librdf_new_world')) # Start of librdf_free_world `librdf_free_world` = function(world) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") ;.Call('R_swig_librdf_free_world', world, PACKAGE='redland'); } attr(`librdf_free_world`, 'returnType') = 'void' attr(`librdf_free_world`, "inputTypes") = c('_p_librdf_world_s') class(`librdf_free_world`) = c("SWIGFunction", class('librdf_free_world')) # Start of librdf_world_open `librdf_world_open` = function(world) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") ;.Call('R_swig_librdf_world_open', world, PACKAGE='redland'); } attr(`librdf_world_open`, 'returnType') = 'void' attr(`librdf_world_open`, "inputTypes") = c('_p_librdf_world_s') class(`librdf_world_open`) = c("SWIGFunction", class('librdf_world_open')) # Start of librdf_world_get_feature `librdf_world_get_feature` = function(world, feature) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") if (inherits(feature, "ExternalReference")) feature = slot(feature,"ref") ;ans = .Call('R_swig_librdf_world_get_feature', world, feature, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_world_get_feature`, 'returnType') = '_p_librdf_node_s' attr(`librdf_world_get_feature`, "inputTypes") = c('_p_librdf_world_s', '_p_librdf_uri_s') class(`librdf_world_get_feature`) = c("SWIGFunction", class('librdf_world_get_feature')) # Start of librdf_world_set_feature `librdf_world_set_feature` = function(world, feature, value, .copy = FALSE) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") if (inherits(feature, "ExternalReference")) feature = slot(feature,"ref") if (inherits(value, "ExternalReference")) value = slot(value,"ref") ;.Call('R_swig_librdf_world_set_feature', world, feature, value, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_world_set_feature`, 'returnType') = 'integer' attr(`librdf_world_set_feature`, "inputTypes") = c('_p_librdf_world_s', '_p_librdf_uri_s', '_p_librdf_node_s') class(`librdf_world_set_feature`) = c("SWIGFunction", class('librdf_world_set_feature')) # Start of librdf_parser_get_accept_header `librdf_parser_get_accept_header` = function(parser) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") ;.Call('R_swig_librdf_parser_get_accept_header', parser, PACKAGE='redland'); } attr(`librdf_parser_get_accept_header`, 'returnType') = 'character' attr(`librdf_parser_get_accept_header`, "inputTypes") = c('_p_librdf_parser_s') class(`librdf_parser_get_accept_header`) = c("SWIGFunction", class('librdf_parser_get_accept_header')) # Start of librdf_world_set_logger `librdf_world_set_logger` = function(world, user_data, log_handler) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") if (inherits(user_data, "ExternalReference")) user_data = slot(user_data,"ref") if (inherits(log_handler, "ExternalReference")) log_handler = slot(log_handler,"ref") ;.Call('R_swig_librdf_world_set_logger', world, user_data, log_handler, PACKAGE='redland'); } attr(`librdf_world_set_logger`, 'returnType') = 'void' attr(`librdf_world_set_logger`, "inputTypes") = c('_p_librdf_world_s', '_p_void', '_p_librdf_log_func') class(`librdf_world_set_logger`) = c("SWIGFunction", class('librdf_world_set_logger')) # Start of librdf_free_iterator `librdf_free_iterator` = function(s_arg1) { if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") ;.Call('R_swig_librdf_free_iterator', s_arg1, PACKAGE='redland'); } attr(`librdf_free_iterator`, 'returnType') = 'void' attr(`librdf_free_iterator`, "inputTypes") = c('_p_librdf_iterator_s') class(`librdf_free_iterator`) = c("SWIGFunction", class('librdf_free_iterator')) # Start of librdf_iterator_end `librdf_iterator_end` = function(iterator, .copy = FALSE) { if (inherits(iterator, "ExternalReference")) iterator = slot(iterator,"ref") ;.Call('R_swig_librdf_iterator_end', iterator, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_iterator_end`, 'returnType') = 'integer' attr(`librdf_iterator_end`, "inputTypes") = c('_p_librdf_iterator_s') class(`librdf_iterator_end`) = c("SWIGFunction", class('librdf_iterator_end')) # Start of librdf_iterator_get_object `librdf_iterator_get_object` = function(iterator) { if (inherits(iterator, "ExternalReference")) iterator = slot(iterator,"ref") ;ans = .Call('R_swig_librdf_iterator_get_object', iterator, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_iterator_get_object`, 'returnType') = '_p_librdf_node_s' attr(`librdf_iterator_get_object`, "inputTypes") = c('_p_librdf_iterator_s') class(`librdf_iterator_get_object`) = c("SWIGFunction", class('librdf_iterator_get_object')) # Start of librdf_iterator_get_context `librdf_iterator_get_context` = function(iterator) { if (inherits(iterator, "ExternalReference")) iterator = slot(iterator,"ref") ;ans = .Call('R_swig_librdf_iterator_get_context', iterator, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_iterator_get_context`, 'returnType') = '_p_librdf_node_s' attr(`librdf_iterator_get_context`, "inputTypes") = c('_p_librdf_iterator_s') class(`librdf_iterator_get_context`) = c("SWIGFunction", class('librdf_iterator_get_context')) # Start of librdf_iterator_next `librdf_iterator_next` = function(iterator, .copy = FALSE) { if (inherits(iterator, "ExternalReference")) iterator = slot(iterator,"ref") ;.Call('R_swig_librdf_iterator_next', iterator, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_iterator_next`, 'returnType') = 'integer' attr(`librdf_iterator_next`, "inputTypes") = c('_p_librdf_iterator_s') class(`librdf_iterator_next`) = c("SWIGFunction", class('librdf_iterator_next')) # Start of librdf_new_uri `librdf_new_uri` = function(world, string) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") string = as(string, "character"); ;ans = .Call('R_swig_librdf_new_uri', world, string, PACKAGE='redland'); ans <- new("_p_librdf_uri_s", ref=ans) ; ans } attr(`librdf_new_uri`, 'returnType') = '_p_librdf_uri_s' attr(`librdf_new_uri`, "inputTypes") = c('_p_librdf_world_s', 'character') class(`librdf_new_uri`) = c("SWIGFunction", class('librdf_new_uri')) # Start of librdf_new_uri_from_uri `librdf_new_uri_from_uri` = function(uri) { if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") ;ans = .Call('R_swig_librdf_new_uri_from_uri', uri, PACKAGE='redland'); ans <- new("_p_librdf_uri_s", ref=ans) ; ans } attr(`librdf_new_uri_from_uri`, 'returnType') = '_p_librdf_uri_s' attr(`librdf_new_uri_from_uri`, "inputTypes") = c('_p_librdf_uri_s') class(`librdf_new_uri_from_uri`) = c("SWIGFunction", class('librdf_new_uri_from_uri')) # Start of librdf_new_uri_from_filename `librdf_new_uri_from_filename` = function(world, filename) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") filename = as(filename, "character"); ;ans = .Call('R_swig_librdf_new_uri_from_filename', world, filename, PACKAGE='redland'); ans <- new("_p_librdf_uri_s", ref=ans) ; ans } attr(`librdf_new_uri_from_filename`, 'returnType') = '_p_librdf_uri_s' attr(`librdf_new_uri_from_filename`, "inputTypes") = c('_p_librdf_world_s', 'character') class(`librdf_new_uri_from_filename`) = c("SWIGFunction", class('librdf_new_uri_from_filename')) # Start of librdf_free_uri `librdf_free_uri` = function(uri) { if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") ;.Call('R_swig_librdf_free_uri', uri, PACKAGE='redland'); } attr(`librdf_free_uri`, 'returnType') = 'void' attr(`librdf_free_uri`, "inputTypes") = c('_p_librdf_uri_s') class(`librdf_free_uri`) = c("SWIGFunction", class('librdf_free_uri')) # Start of librdf_uri_to_string `librdf_uri_to_string` = function(uri) { if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") ;.Call('R_swig_librdf_uri_to_string', uri, PACKAGE='redland'); } attr(`librdf_uri_to_string`, 'returnType') = 'character' attr(`librdf_uri_to_string`, "inputTypes") = c('_p_librdf_uri_s') class(`librdf_uri_to_string`) = c("SWIGFunction", class('librdf_uri_to_string')) # Start of librdf_uri_equals `librdf_uri_equals` = function(first_uri, second_uri, .copy = FALSE) { if (inherits(first_uri, "ExternalReference")) first_uri = slot(first_uri,"ref") if (inherits(second_uri, "ExternalReference")) second_uri = slot(second_uri,"ref") ;.Call('R_swig_librdf_uri_equals', first_uri, second_uri, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_uri_equals`, 'returnType') = 'integer' attr(`librdf_uri_equals`, "inputTypes") = c('_p_librdf_uri_s', '_p_librdf_uri_s') class(`librdf_uri_equals`) = c("SWIGFunction", class('librdf_uri_equals')) # Start of librdf_uri_compare `librdf_uri_compare` = function(first_uri, second_uri, .copy = FALSE) { if (inherits(first_uri, "ExternalReference")) first_uri = slot(first_uri,"ref") if (inherits(second_uri, "ExternalReference")) second_uri = slot(second_uri,"ref") ;.Call('R_swig_librdf_uri_compare', first_uri, second_uri, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_uri_compare`, 'returnType') = 'integer' attr(`librdf_uri_compare`, "inputTypes") = c('_p_librdf_uri_s', '_p_librdf_uri_s') class(`librdf_uri_compare`) = c("SWIGFunction", class('librdf_uri_compare')) # Start of librdf_new_node `librdf_new_node` = function(world) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") ;ans = .Call('R_swig_librdf_new_node', world, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node`, "inputTypes") = c('_p_librdf_world_s') class(`librdf_new_node`) = c("SWIGFunction", class('librdf_new_node')) # Start of librdf_new_node_from_uri_string `librdf_new_node_from_uri_string` = function(world, string) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") string = as(string, "character"); ;ans = .Call('R_swig_librdf_new_node_from_uri_string', world, string, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node_from_uri_string`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node_from_uri_string`, "inputTypes") = c('_p_librdf_world_s', 'character') class(`librdf_new_node_from_uri_string`) = c("SWIGFunction", class('librdf_new_node_from_uri_string')) # Start of librdf_new_node_from_uri `librdf_new_node_from_uri` = function(world, uri) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") ;ans = .Call('R_swig_librdf_new_node_from_uri', world, uri, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node_from_uri`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node_from_uri`, "inputTypes") = c('_p_librdf_world_s', '_p_librdf_uri_s') class(`librdf_new_node_from_uri`) = c("SWIGFunction", class('librdf_new_node_from_uri')) # Start of librdf_new_node_from_uri_local_name `librdf_new_node_from_uri_local_name` = function(world, uri, local_name) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") local_name = as(local_name, "character"); ;ans = .Call('R_swig_librdf_new_node_from_uri_local_name', world, uri, local_name, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node_from_uri_local_name`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node_from_uri_local_name`, "inputTypes") = c('_p_librdf_world_s', '_p_librdf_uri_s', 'character') class(`librdf_new_node_from_uri_local_name`) = c("SWIGFunction", class('librdf_new_node_from_uri_local_name')) # Start of librdf_new_node_from_normalised_uri_string `librdf_new_node_from_normalised_uri_string` = function(world, uri_string, source_uri, base_uri) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") uri_string = as(uri_string, "character"); if (inherits(source_uri, "ExternalReference")) source_uri = slot(source_uri,"ref") if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") ;ans = .Call('R_swig_librdf_new_node_from_normalised_uri_string', world, uri_string, source_uri, base_uri, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node_from_normalised_uri_string`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node_from_normalised_uri_string`, "inputTypes") = c('_p_librdf_world_s', 'character', '_p_librdf_uri_s', '_p_librdf_uri_s') class(`librdf_new_node_from_normalised_uri_string`) = c("SWIGFunction", class('librdf_new_node_from_normalised_uri_string')) # Start of librdf_new_node_from_literal `librdf_new_node_from_literal` = function(world, string, inStrOrNull, is_wf_xml) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") string = as(string, "character"); inStrOrNull = as(inStrOrNull, "character"); is_wf_xml = as.integer(is_wf_xml); if(length(is_wf_xml) > 1) { warning("using only the first element of is_wf_xml"); }; ;ans = .Call('R_swig_librdf_new_node_from_literal', world, string, inStrOrNull, is_wf_xml, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node_from_literal`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node_from_literal`, "inputTypes") = c('_p_librdf_world_s', 'character', 'character', 'integer') class(`librdf_new_node_from_literal`) = c("SWIGFunction", class('librdf_new_node_from_literal')) # Start of librdf_new_node_from_typed_literal `librdf_new_node_from_typed_literal` = function(world, string, inStrOrNull, inUriOrNull) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") string = as(string, "character"); inStrOrNull = as(inStrOrNull, "character"); if (inherits(inUriOrNull, "ExternalReference")) inUriOrNull = slot(inUriOrNull,"ref") ;ans = .Call('R_swig_librdf_new_node_from_typed_literal', world, string, inStrOrNull, inUriOrNull, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node_from_typed_literal`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node_from_typed_literal`, "inputTypes") = c('_p_librdf_world_s', 'character', 'character', '_p_librdf_uri_s') class(`librdf_new_node_from_typed_literal`) = c("SWIGFunction", class('librdf_new_node_from_typed_literal')) # Start of librdf_new_node_from_node `librdf_new_node_from_node` = function(node) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;ans = .Call('R_swig_librdf_new_node_from_node', node, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node_from_node`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node_from_node`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_new_node_from_node`) = c("SWIGFunction", class('librdf_new_node_from_node')) # Start of librdf_new_node_from_blank_identifier `librdf_new_node_from_blank_identifier` = function(world, inStrOrNull) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") inStrOrNull = as(inStrOrNull, "character"); ;ans = .Call('R_swig_librdf_new_node_from_blank_identifier', world, inStrOrNull, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_new_node_from_blank_identifier`, 'returnType') = '_p_librdf_node_s' attr(`librdf_new_node_from_blank_identifier`, "inputTypes") = c('_p_librdf_world_s', 'character') class(`librdf_new_node_from_blank_identifier`) = c("SWIGFunction", class('librdf_new_node_from_blank_identifier')) # Start of librdf_free_node `librdf_free_node` = function(r) { if (inherits(r, "ExternalReference")) r = slot(r,"ref") ;.Call('R_swig_librdf_free_node', r, PACKAGE='redland'); } attr(`librdf_free_node`, 'returnType') = 'void' attr(`librdf_free_node`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_free_node`) = c("SWIGFunction", class('librdf_free_node')) # Start of librdf_node_get_uri `librdf_node_get_uri` = function(node) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;ans = .Call('R_swig_librdf_node_get_uri', node, PACKAGE='redland'); ans <- new("_p_librdf_uri_s", ref=ans) ; ans } attr(`librdf_node_get_uri`, 'returnType') = '_p_librdf_uri_s' attr(`librdf_node_get_uri`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_uri`) = c("SWIGFunction", class('librdf_node_get_uri')) # Start of librdf_node_get_type `librdf_node_get_type` = function(node, .copy = FALSE) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_get_type', node, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_node_get_type`, 'returnType') = 'integer' attr(`librdf_node_get_type`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_type`) = c("SWIGFunction", class('librdf_node_get_type')) # Start of librdf_node_get_literal_value `librdf_node_get_literal_value` = function(node) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_get_literal_value', node, PACKAGE='redland'); } attr(`librdf_node_get_literal_value`, 'returnType') = 'character' attr(`librdf_node_get_literal_value`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_literal_value`) = c("SWIGFunction", class('librdf_node_get_literal_value')) # Start of librdf_node_get_literal_value_as_latin1 `librdf_node_get_literal_value_as_latin1` = function(node) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_get_literal_value_as_latin1', node, PACKAGE='redland'); } attr(`librdf_node_get_literal_value_as_latin1`, 'returnType') = 'character' attr(`librdf_node_get_literal_value_as_latin1`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_literal_value_as_latin1`) = c("SWIGFunction", class('librdf_node_get_literal_value_as_latin1')) # Start of librdf_node_get_literal_value_language `librdf_node_get_literal_value_language` = function(node) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_get_literal_value_language', node, PACKAGE='redland'); } attr(`librdf_node_get_literal_value_language`, 'returnType') = 'character' attr(`librdf_node_get_literal_value_language`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_literal_value_language`) = c("SWIGFunction", class('librdf_node_get_literal_value_language')) # Start of librdf_node_get_literal_value_datatype_uri `librdf_node_get_literal_value_datatype_uri` = function(node) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;ans = .Call('R_swig_librdf_node_get_literal_value_datatype_uri', node, PACKAGE='redland'); ans <- new("_p_librdf_uri_s", ref=ans) ; ans } attr(`librdf_node_get_literal_value_datatype_uri`, 'returnType') = '_p_librdf_uri_s' attr(`librdf_node_get_literal_value_datatype_uri`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_literal_value_datatype_uri`) = c("SWIGFunction", class('librdf_node_get_literal_value_datatype_uri')) # Start of librdf_node_get_literal_value_is_wf_xml `librdf_node_get_literal_value_is_wf_xml` = function(node, .copy = FALSE) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_get_literal_value_is_wf_xml', node, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_node_get_literal_value_is_wf_xml`, 'returnType') = 'integer' attr(`librdf_node_get_literal_value_is_wf_xml`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_literal_value_is_wf_xml`) = c("SWIGFunction", class('librdf_node_get_literal_value_is_wf_xml')) # Start of librdf_node_get_li_ordinal `librdf_node_get_li_ordinal` = function(node, .copy = FALSE) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_get_li_ordinal', node, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_node_get_li_ordinal`, 'returnType') = 'integer' attr(`librdf_node_get_li_ordinal`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_li_ordinal`) = c("SWIGFunction", class('librdf_node_get_li_ordinal')) # Start of librdf_node_get_blank_identifier `librdf_node_get_blank_identifier` = function(node) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_get_blank_identifier', node, PACKAGE='redland'); } attr(`librdf_node_get_blank_identifier`, 'returnType') = 'character' attr(`librdf_node_get_blank_identifier`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_get_blank_identifier`) = c("SWIGFunction", class('librdf_node_get_blank_identifier')) # Start of librdf_node_is_resource `librdf_node_is_resource` = function(node, .copy = FALSE) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_is_resource', node, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_node_is_resource`, 'returnType') = 'integer' attr(`librdf_node_is_resource`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_is_resource`) = c("SWIGFunction", class('librdf_node_is_resource')) # Start of librdf_node_is_literal `librdf_node_is_literal` = function(node, .copy = FALSE) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_is_literal', node, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_node_is_literal`, 'returnType') = 'integer' attr(`librdf_node_is_literal`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_is_literal`) = c("SWIGFunction", class('librdf_node_is_literal')) # Start of librdf_node_is_blank `librdf_node_is_blank` = function(node, .copy = FALSE) { if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;.Call('R_swig_librdf_node_is_blank', node, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_node_is_blank`, 'returnType') = 'integer' attr(`librdf_node_is_blank`, "inputTypes") = c('_p_librdf_node_s') class(`librdf_node_is_blank`) = c("SWIGFunction", class('librdf_node_is_blank')) # Start of librdf_node_equals `librdf_node_equals` = function(first_node, second_node, .copy = FALSE) { if (inherits(first_node, "ExternalReference")) first_node = slot(first_node,"ref") if (inherits(second_node, "ExternalReference")) second_node = slot(second_node,"ref") ;.Call('R_swig_librdf_node_equals', first_node, second_node, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_node_equals`, 'returnType') = 'integer' attr(`librdf_node_equals`, "inputTypes") = c('_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_node_equals`) = c("SWIGFunction", class('librdf_node_equals')) # Start of librdf_new_statement `librdf_new_statement` = function(world) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") ;ans = .Call('R_swig_librdf_new_statement', world, PACKAGE='redland'); ans <- new("_p_librdf_statement_s", ref=ans) ; ans } attr(`librdf_new_statement`, 'returnType') = '_p_librdf_statement_s' attr(`librdf_new_statement`, "inputTypes") = c('_p_librdf_world_s') class(`librdf_new_statement`) = c("SWIGFunction", class('librdf_new_statement')) # Start of librdf_new_statement_from_statement `librdf_new_statement_from_statement` = function(statement) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;ans = .Call('R_swig_librdf_new_statement_from_statement', statement, PACKAGE='redland'); ans <- new("_p_librdf_statement_s", ref=ans) ; ans } attr(`librdf_new_statement_from_statement`, 'returnType') = '_p_librdf_statement_s' attr(`librdf_new_statement_from_statement`, "inputTypes") = c('_p_librdf_statement_s') class(`librdf_new_statement_from_statement`) = c("SWIGFunction", class('librdf_new_statement_from_statement')) # Start of librdf_new_statement_from_nodes `librdf_new_statement_from_nodes` = function(world, subject, predicate, object) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") if (inherits(subject, "ExternalReference")) subject = slot(subject,"ref") if (inherits(predicate, "ExternalReference")) predicate = slot(predicate,"ref") if (inherits(object, "ExternalReference")) object = slot(object,"ref") ;ans = .Call('R_swig_librdf_new_statement_from_nodes', world, subject, predicate, object, PACKAGE='redland'); ans <- new("_p_librdf_statement_s", ref=ans) ; ans } attr(`librdf_new_statement_from_nodes`, 'returnType') = '_p_librdf_statement_s' attr(`librdf_new_statement_from_nodes`, "inputTypes") = c('_p_librdf_world_s', '_p_librdf_node_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_new_statement_from_nodes`) = c("SWIGFunction", class('librdf_new_statement_from_nodes')) # Start of librdf_free_statement `librdf_free_statement` = function(statement) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;.Call('R_swig_librdf_free_statement', statement, PACKAGE='redland'); } attr(`librdf_free_statement`, 'returnType') = 'void' attr(`librdf_free_statement`, "inputTypes") = c('_p_librdf_statement_s') class(`librdf_free_statement`) = c("SWIGFunction", class('librdf_free_statement')) # Start of librdf_statement_get_subject `librdf_statement_get_subject` = function(statement) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;ans = .Call('R_swig_librdf_statement_get_subject', statement, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_statement_get_subject`, 'returnType') = '_p_librdf_node_s' attr(`librdf_statement_get_subject`, "inputTypes") = c('_p_librdf_statement_s') class(`librdf_statement_get_subject`) = c("SWIGFunction", class('librdf_statement_get_subject')) # Start of librdf_statement_set_subject `librdf_statement_set_subject` = function(statement, subject) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") if (inherits(subject, "ExternalReference")) subject = slot(subject,"ref") ;.Call('R_swig_librdf_statement_set_subject', statement, subject, PACKAGE='redland'); } attr(`librdf_statement_set_subject`, 'returnType') = 'void' attr(`librdf_statement_set_subject`, "inputTypes") = c('_p_librdf_statement_s', '_p_librdf_node_s') class(`librdf_statement_set_subject`) = c("SWIGFunction", class('librdf_statement_set_subject')) # Start of librdf_statement_get_predicate `librdf_statement_get_predicate` = function(statement) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;ans = .Call('R_swig_librdf_statement_get_predicate', statement, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_statement_get_predicate`, 'returnType') = '_p_librdf_node_s' attr(`librdf_statement_get_predicate`, "inputTypes") = c('_p_librdf_statement_s') class(`librdf_statement_get_predicate`) = c("SWIGFunction", class('librdf_statement_get_predicate')) # Start of librdf_statement_set_predicate `librdf_statement_set_predicate` = function(statement, predicate) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") if (inherits(predicate, "ExternalReference")) predicate = slot(predicate,"ref") ;.Call('R_swig_librdf_statement_set_predicate', statement, predicate, PACKAGE='redland'); } attr(`librdf_statement_set_predicate`, 'returnType') = 'void' attr(`librdf_statement_set_predicate`, "inputTypes") = c('_p_librdf_statement_s', '_p_librdf_node_s') class(`librdf_statement_set_predicate`) = c("SWIGFunction", class('librdf_statement_set_predicate')) # Start of librdf_statement_get_object `librdf_statement_get_object` = function(statement) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;ans = .Call('R_swig_librdf_statement_get_object', statement, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_statement_get_object`, 'returnType') = '_p_librdf_node_s' attr(`librdf_statement_get_object`, "inputTypes") = c('_p_librdf_statement_s') class(`librdf_statement_get_object`) = c("SWIGFunction", class('librdf_statement_get_object')) # Start of librdf_statement_set_object `librdf_statement_set_object` = function(statement, object) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") if (inherits(object, "ExternalReference")) object = slot(object,"ref") ;.Call('R_swig_librdf_statement_set_object', statement, object, PACKAGE='redland'); } attr(`librdf_statement_set_object`, 'returnType') = 'void' attr(`librdf_statement_set_object`, "inputTypes") = c('_p_librdf_statement_s', '_p_librdf_node_s') class(`librdf_statement_set_object`) = c("SWIGFunction", class('librdf_statement_set_object')) # Start of librdf_statement_equals `librdf_statement_equals` = function(statement1, statement2, .copy = FALSE) { if (inherits(statement1, "ExternalReference")) statement1 = slot(statement1,"ref") if (inherits(statement2, "ExternalReference")) statement2 = slot(statement2,"ref") ;.Call('R_swig_librdf_statement_equals', statement1, statement2, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_statement_equals`, 'returnType') = 'integer' attr(`librdf_statement_equals`, "inputTypes") = c('_p_librdf_statement_s', '_p_librdf_statement_s') class(`librdf_statement_equals`) = c("SWIGFunction", class('librdf_statement_equals')) # Start of librdf_statement_match `librdf_statement_match` = function(statement, partial_statement, .copy = FALSE) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") if (inherits(partial_statement, "ExternalReference")) partial_statement = slot(partial_statement,"ref") ;.Call('R_swig_librdf_statement_match', statement, partial_statement, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_statement_match`, 'returnType') = 'integer' attr(`librdf_statement_match`, "inputTypes") = c('_p_librdf_statement_s', '_p_librdf_statement_s') class(`librdf_statement_match`) = c("SWIGFunction", class('librdf_statement_match')) # Start of librdf_statement_is_complete `librdf_statement_is_complete` = function(statement, .copy = FALSE) { if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;.Call('R_swig_librdf_statement_is_complete', statement, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_statement_is_complete`, 'returnType') = 'integer' attr(`librdf_statement_is_complete`, "inputTypes") = c('_p_librdf_statement_s') class(`librdf_statement_is_complete`) = c("SWIGFunction", class('librdf_statement_is_complete')) # Start of librdf_new_model `librdf_new_model` = function(world, storage, options_string) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") if (inherits(storage, "ExternalReference")) storage = slot(storage,"ref") options_string = as(options_string, "character"); ;ans = .Call('R_swig_librdf_new_model', world, storage, options_string, PACKAGE='redland'); ans <- new("_p_librdf_model_s", ref=ans) ; ans } attr(`librdf_new_model`, 'returnType') = '_p_librdf_model_s' attr(`librdf_new_model`, "inputTypes") = c('_p_librdf_world_s', '_p_librdf_storage_s', 'character') class(`librdf_new_model`) = c("SWIGFunction", class('librdf_new_model')) # Start of librdf_new_model_with_options `librdf_new_model_with_options` = function(world, storage, options) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") if (inherits(storage, "ExternalReference")) storage = slot(storage,"ref") if (inherits(options, "ExternalReference")) options = slot(options,"ref") ;ans = .Call('R_swig_librdf_new_model_with_options', world, storage, options, PACKAGE='redland'); ans <- new("_p_librdf_model_s", ref=ans) ; ans } attr(`librdf_new_model_with_options`, 'returnType') = '_p_librdf_model_s' attr(`librdf_new_model_with_options`, "inputTypes") = c('_p_librdf_world_s', '_p_librdf_storage_s', '_p_librdf_hash_s') class(`librdf_new_model_with_options`) = c("SWIGFunction", class('librdf_new_model_with_options')) # Start of librdf_new_model_from_model `librdf_new_model_from_model` = function(model) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;ans = .Call('R_swig_librdf_new_model_from_model', model, PACKAGE='redland'); ans <- new("_p_librdf_model_s", ref=ans) ; ans } attr(`librdf_new_model_from_model`, 'returnType') = '_p_librdf_model_s' attr(`librdf_new_model_from_model`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_new_model_from_model`) = c("SWIGFunction", class('librdf_new_model_from_model')) # Start of librdf_free_model `librdf_free_model` = function(model) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_free_model', model, PACKAGE='redland'); } attr(`librdf_free_model`, 'returnType') = 'void' attr(`librdf_free_model`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_free_model`) = c("SWIGFunction", class('librdf_free_model')) # Start of librdf_model_size `librdf_model_size` = function(model, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_model_size', model, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_size`, 'returnType') = 'integer' attr(`librdf_model_size`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_model_size`) = c("SWIGFunction", class('librdf_model_size')) # Start of librdf_model_add `librdf_model_add` = function(model, subject, predicate, object, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(subject, "ExternalReference")) subject = slot(subject,"ref") if (inherits(predicate, "ExternalReference")) predicate = slot(predicate,"ref") if (inherits(object, "ExternalReference")) object = slot(object,"ref") ;.Call('R_swig_librdf_model_add', model, subject, predicate, object, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_add`, 'returnType') = 'integer' attr(`librdf_model_add`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_add`) = c("SWIGFunction", class('librdf_model_add')) # Start of librdf_model_add_string_literal_statement `librdf_model_add_string_literal_statement` = function(model, subject, predicate, literal, inStrOrNull, is_wf_xml, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(subject, "ExternalReference")) subject = slot(subject,"ref") if (inherits(predicate, "ExternalReference")) predicate = slot(predicate,"ref") literal = as(literal, "character"); inStrOrNull = as(inStrOrNull, "character"); is_wf_xml = as.integer(is_wf_xml); if(length(is_wf_xml) > 1) { warning("using only the first element of is_wf_xml"); }; ;.Call('R_swig_librdf_model_add_string_literal_statement', model, subject, predicate, literal, inStrOrNull, is_wf_xml, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_add_string_literal_statement`, 'returnType') = 'integer' attr(`librdf_model_add_string_literal_statement`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s', 'character', 'character', 'integer') class(`librdf_model_add_string_literal_statement`) = c("SWIGFunction", class('librdf_model_add_string_literal_statement')) # Start of librdf_model_add_typed_literal_statement `librdf_model_add_typed_literal_statement` = function(model, subject, predicate, string, inStrOrNull, inUriOrNull, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(subject, "ExternalReference")) subject = slot(subject,"ref") if (inherits(predicate, "ExternalReference")) predicate = slot(predicate,"ref") string = as(string, "character"); inStrOrNull = as(inStrOrNull, "character"); if (inherits(inUriOrNull, "ExternalReference")) inUriOrNull = slot(inUriOrNull,"ref") ;.Call('R_swig_librdf_model_add_typed_literal_statement', model, subject, predicate, string, inStrOrNull, inUriOrNull, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_add_typed_literal_statement`, 'returnType') = 'integer' attr(`librdf_model_add_typed_literal_statement`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s', 'character', 'character', '_p_librdf_uri_s') class(`librdf_model_add_typed_literal_statement`) = c("SWIGFunction", class('librdf_model_add_typed_literal_statement')) # Start of librdf_model_add_statement `librdf_model_add_statement` = function(model, statement, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;.Call('R_swig_librdf_model_add_statement', model, statement, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_add_statement`, 'returnType') = 'integer' attr(`librdf_model_add_statement`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_statement_s') class(`librdf_model_add_statement`) = c("SWIGFunction", class('librdf_model_add_statement')) # Start of librdf_model_add_statements `librdf_model_add_statements` = function(model, statement_stream, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(statement_stream, "ExternalReference")) statement_stream = slot(statement_stream,"ref") ;.Call('R_swig_librdf_model_add_statements', model, statement_stream, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_add_statements`, 'returnType') = 'integer' attr(`librdf_model_add_statements`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_stream_s') class(`librdf_model_add_statements`) = c("SWIGFunction", class('librdf_model_add_statements')) # Start of librdf_model_remove_statement `librdf_model_remove_statement` = function(model, statement, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;.Call('R_swig_librdf_model_remove_statement', model, statement, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_remove_statement`, 'returnType') = 'integer' attr(`librdf_model_remove_statement`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_statement_s') class(`librdf_model_remove_statement`) = c("SWIGFunction", class('librdf_model_remove_statement')) # Start of librdf_model_contains_statement `librdf_model_contains_statement` = function(model, statement, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;.Call('R_swig_librdf_model_contains_statement', model, statement, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_contains_statement`, 'returnType') = 'integer' attr(`librdf_model_contains_statement`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_statement_s') class(`librdf_model_contains_statement`) = c("SWIGFunction", class('librdf_model_contains_statement')) # Start of librdf_model_as_stream `librdf_model_as_stream` = function(model) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;ans = .Call('R_swig_librdf_model_as_stream', model, PACKAGE='redland'); ans <- new("_p_librdf_stream_s", ref=ans) ; ans } attr(`librdf_model_as_stream`, 'returnType') = '_p_librdf_stream_s' attr(`librdf_model_as_stream`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_model_as_stream`) = c("SWIGFunction", class('librdf_model_as_stream')) # Start of librdf_model_find_statements `librdf_model_find_statements` = function(model, statement) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;ans = .Call('R_swig_librdf_model_find_statements', model, statement, PACKAGE='redland'); ans <- new("_p_librdf_stream_s", ref=ans) ; ans } attr(`librdf_model_find_statements`, 'returnType') = '_p_librdf_stream_s' attr(`librdf_model_find_statements`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_statement_s') class(`librdf_model_find_statements`) = c("SWIGFunction", class('librdf_model_find_statements')) # Start of librdf_model_find_statements_in_context `librdf_model_find_statements_in_context` = function(model, statement, inNodeOrNull) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") if (inherits(inNodeOrNull, "ExternalReference")) inNodeOrNull = slot(inNodeOrNull,"ref") ;ans = .Call('R_swig_librdf_model_find_statements_in_context', model, statement, inNodeOrNull, PACKAGE='redland'); ans <- new("_p_librdf_stream_s", ref=ans) ; ans } attr(`librdf_model_find_statements_in_context`, 'returnType') = '_p_librdf_stream_s' attr(`librdf_model_find_statements_in_context`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_statement_s', '_p_librdf_node_s') class(`librdf_model_find_statements_in_context`) = c("SWIGFunction", class('librdf_model_find_statements_in_context')) # Start of librdf_model_get_sources `librdf_model_get_sources` = function(model, arc, target) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(arc, "ExternalReference")) arc = slot(arc,"ref") if (inherits(target, "ExternalReference")) target = slot(target,"ref") ;ans = .Call('R_swig_librdf_model_get_sources', model, arc, target, PACKAGE='redland'); ans <- new("_p_librdf_iterator_s", ref=ans) ; ans } attr(`librdf_model_get_sources`, 'returnType') = '_p_librdf_iterator_s' attr(`librdf_model_get_sources`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_get_sources`) = c("SWIGFunction", class('librdf_model_get_sources')) # Start of librdf_model_get_arcs `librdf_model_get_arcs` = function(model, source, target) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(source, "ExternalReference")) source = slot(source,"ref") if (inherits(target, "ExternalReference")) target = slot(target,"ref") ;ans = .Call('R_swig_librdf_model_get_arcs', model, source, target, PACKAGE='redland'); ans <- new("_p_librdf_iterator_s", ref=ans) ; ans } attr(`librdf_model_get_arcs`, 'returnType') = '_p_librdf_iterator_s' attr(`librdf_model_get_arcs`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_get_arcs`) = c("SWIGFunction", class('librdf_model_get_arcs')) # Start of librdf_model_get_targets `librdf_model_get_targets` = function(model, source, arc) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(source, "ExternalReference")) source = slot(source,"ref") if (inherits(arc, "ExternalReference")) arc = slot(arc,"ref") ;ans = .Call('R_swig_librdf_model_get_targets', model, source, arc, PACKAGE='redland'); ans <- new("_p_librdf_iterator_s", ref=ans) ; ans } attr(`librdf_model_get_targets`, 'returnType') = '_p_librdf_iterator_s' attr(`librdf_model_get_targets`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_get_targets`) = c("SWIGFunction", class('librdf_model_get_targets')) # Start of librdf_model_get_source `librdf_model_get_source` = function(model, arc, target) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(arc, "ExternalReference")) arc = slot(arc,"ref") if (inherits(target, "ExternalReference")) target = slot(target,"ref") ;ans = .Call('R_swig_librdf_model_get_source', model, arc, target, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_model_get_source`, 'returnType') = '_p_librdf_node_s' attr(`librdf_model_get_source`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_get_source`) = c("SWIGFunction", class('librdf_model_get_source')) # Start of librdf_model_get_arc `librdf_model_get_arc` = function(model, source, target) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(source, "ExternalReference")) source = slot(source,"ref") if (inherits(target, "ExternalReference")) target = slot(target,"ref") ;ans = .Call('R_swig_librdf_model_get_arc', model, source, target, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_model_get_arc`, 'returnType') = '_p_librdf_node_s' attr(`librdf_model_get_arc`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_get_arc`) = c("SWIGFunction", class('librdf_model_get_arc')) # Start of librdf_model_get_arcs_out `librdf_model_get_arcs_out` = function(model, node) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;ans = .Call('R_swig_librdf_model_get_arcs_out', model, node, PACKAGE='redland'); ans <- new("_p_librdf_iterator_s", ref=ans) ; ans } attr(`librdf_model_get_arcs_out`, 'returnType') = '_p_librdf_iterator_s' attr(`librdf_model_get_arcs_out`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s') class(`librdf_model_get_arcs_out`) = c("SWIGFunction", class('librdf_model_get_arcs_out')) # Start of librdf_model_get_arcs_in `librdf_model_get_arcs_in` = function(model, node) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(node, "ExternalReference")) node = slot(node,"ref") ;ans = .Call('R_swig_librdf_model_get_arcs_in', model, node, PACKAGE='redland'); ans <- new("_p_librdf_iterator_s", ref=ans) ; ans } attr(`librdf_model_get_arcs_in`, 'returnType') = '_p_librdf_iterator_s' attr(`librdf_model_get_arcs_in`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s') class(`librdf_model_get_arcs_in`) = c("SWIGFunction", class('librdf_model_get_arcs_in')) # Start of librdf_model_has_arc_in `librdf_model_has_arc_in` = function(model, node, property, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(node, "ExternalReference")) node = slot(node,"ref") if (inherits(property, "ExternalReference")) property = slot(property,"ref") ;.Call('R_swig_librdf_model_has_arc_in', model, node, property, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_has_arc_in`, 'returnType') = 'integer' attr(`librdf_model_has_arc_in`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_has_arc_in`) = c("SWIGFunction", class('librdf_model_has_arc_in')) # Start of librdf_model_has_arc_out `librdf_model_has_arc_out` = function(model, node, property, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(node, "ExternalReference")) node = slot(node,"ref") if (inherits(property, "ExternalReference")) property = slot(property,"ref") ;.Call('R_swig_librdf_model_has_arc_out', model, node, property, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_has_arc_out`, 'returnType') = 'integer' attr(`librdf_model_has_arc_out`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_has_arc_out`) = c("SWIGFunction", class('librdf_model_has_arc_out')) # Start of librdf_model_get_target `librdf_model_get_target` = function(model, source, arc) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(source, "ExternalReference")) source = slot(source,"ref") if (inherits(arc, "ExternalReference")) arc = slot(arc,"ref") ;ans = .Call('R_swig_librdf_model_get_target', model, source, arc, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_model_get_target`, 'returnType') = '_p_librdf_node_s' attr(`librdf_model_get_target`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_node_s') class(`librdf_model_get_target`) = c("SWIGFunction", class('librdf_model_get_target')) # Start of librdf_model_context_add_statement `librdf_model_context_add_statement` = function(model, context, statement, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(context, "ExternalReference")) context = slot(context,"ref") if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;.Call('R_swig_librdf_model_context_add_statement', model, context, statement, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_context_add_statement`, 'returnType') = 'integer' attr(`librdf_model_context_add_statement`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_statement_s') class(`librdf_model_context_add_statement`) = c("SWIGFunction", class('librdf_model_context_add_statement')) # Start of librdf_model_context_add_statements `librdf_model_context_add_statements` = function(model, context, stream, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(context, "ExternalReference")) context = slot(context,"ref") if (inherits(stream, "ExternalReference")) stream = slot(stream,"ref") ;.Call('R_swig_librdf_model_context_add_statements', model, context, stream, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_context_add_statements`, 'returnType') = 'integer' attr(`librdf_model_context_add_statements`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_stream_s') class(`librdf_model_context_add_statements`) = c("SWIGFunction", class('librdf_model_context_add_statements')) # Start of librdf_model_context_remove_statement `librdf_model_context_remove_statement` = function(model, context, statement, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(context, "ExternalReference")) context = slot(context,"ref") if (inherits(statement, "ExternalReference")) statement = slot(statement,"ref") ;.Call('R_swig_librdf_model_context_remove_statement', model, context, statement, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_context_remove_statement`, 'returnType') = 'integer' attr(`librdf_model_context_remove_statement`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s', '_p_librdf_statement_s') class(`librdf_model_context_remove_statement`) = c("SWIGFunction", class('librdf_model_context_remove_statement')) # Start of librdf_model_context_remove_statements `librdf_model_context_remove_statements` = function(model, context, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(context, "ExternalReference")) context = slot(context,"ref") ;.Call('R_swig_librdf_model_context_remove_statements', model, context, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_context_remove_statements`, 'returnType') = 'integer' attr(`librdf_model_context_remove_statements`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s') class(`librdf_model_context_remove_statements`) = c("SWIGFunction", class('librdf_model_context_remove_statements')) # Start of librdf_model_context_as_stream `librdf_model_context_as_stream` = function(model, context) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(context, "ExternalReference")) context = slot(context,"ref") ;ans = .Call('R_swig_librdf_model_context_as_stream', model, context, PACKAGE='redland'); ans <- new("_p_librdf_stream_s", ref=ans) ; ans } attr(`librdf_model_context_as_stream`, 'returnType') = '_p_librdf_stream_s' attr(`librdf_model_context_as_stream`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s') class(`librdf_model_context_as_stream`) = c("SWIGFunction", class('librdf_model_context_as_stream')) # Start of librdf_model_sync `librdf_model_sync` = function(model) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_model_sync', model, PACKAGE='redland'); } attr(`librdf_model_sync`, 'returnType') = 'void' attr(`librdf_model_sync`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_model_sync`) = c("SWIGFunction", class('librdf_model_sync')) # Start of librdf_model_get_contexts `librdf_model_get_contexts` = function(model) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;ans = .Call('R_swig_librdf_model_get_contexts', model, PACKAGE='redland'); ans <- new("_p_librdf_iterator_s", ref=ans) ; ans } attr(`librdf_model_get_contexts`, 'returnType') = '_p_librdf_iterator_s' attr(`librdf_model_get_contexts`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_model_get_contexts`) = c("SWIGFunction", class('librdf_model_get_contexts')) # Start of librdf_model_contains_context `librdf_model_contains_context` = function(model, context, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(context, "ExternalReference")) context = slot(context,"ref") ;.Call('R_swig_librdf_model_contains_context', model, context, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_contains_context`, 'returnType') = 'integer' attr(`librdf_model_contains_context`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_node_s') class(`librdf_model_contains_context`) = c("SWIGFunction", class('librdf_model_contains_context')) # Start of librdf_model_get_feature `librdf_model_get_feature` = function(model, feature) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(feature, "ExternalReference")) feature = slot(feature,"ref") ;ans = .Call('R_swig_librdf_model_get_feature', model, feature, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_model_get_feature`, 'returnType') = '_p_librdf_node_s' attr(`librdf_model_get_feature`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_uri_s') class(`librdf_model_get_feature`) = c("SWIGFunction", class('librdf_model_get_feature')) # Start of librdf_model_set_feature `librdf_model_set_feature` = function(model, feature, value, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(feature, "ExternalReference")) feature = slot(feature,"ref") if (inherits(value, "ExternalReference")) value = slot(value,"ref") ;.Call('R_swig_librdf_model_set_feature', model, feature, value, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_set_feature`, 'returnType') = 'integer' attr(`librdf_model_set_feature`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_uri_s', '_p_librdf_node_s') class(`librdf_model_set_feature`) = c("SWIGFunction", class('librdf_model_set_feature')) # Start of librdf_model_load `librdf_model_load` = function(model, uri, name, mime_type, type_uri, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") name = as(name, "character"); mime_type = as(mime_type, "character"); if (inherits(type_uri, "ExternalReference")) type_uri = slot(type_uri,"ref") ;.Call('R_swig_librdf_model_load', model, uri, name, mime_type, type_uri, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_load`, 'returnType') = 'integer' attr(`librdf_model_load`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_uri_s', 'character', 'character', '_p_librdf_uri_s') class(`librdf_model_load`) = c("SWIGFunction", class('librdf_model_load')) # Start of librdf_model_query_execute `librdf_model_query_execute` = function(model, query) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(query, "ExternalReference")) query = slot(query,"ref") ;ans = .Call('R_swig_librdf_model_query_execute', model, query, PACKAGE='redland'); ans <- new("_p_librdf_query_results", ref=ans) ; ans } attr(`librdf_model_query_execute`, 'returnType') = '_p_librdf_query_results' attr(`librdf_model_query_execute`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_query') class(`librdf_model_query_execute`) = c("SWIGFunction", class('librdf_model_query_execute')) # Start of librdf_model_to_string `librdf_model_to_string` = function(model, uri, name, mime_type, inUriOrNull) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") name = as(name, "character"); mime_type = as(mime_type, "character"); if (inherits(inUriOrNull, "ExternalReference")) inUriOrNull = slot(inUriOrNull,"ref") ;.Call('R_swig_librdf_model_to_string', model, uri, name, mime_type, inUriOrNull, PACKAGE='redland'); } attr(`librdf_model_to_string`, 'returnType') = 'character' attr(`librdf_model_to_string`, "inputTypes") = c('_p_librdf_model_s', '_p_librdf_uri_s', 'character', 'character', '_p_librdf_uri_s') class(`librdf_model_to_string`) = c("SWIGFunction", class('librdf_model_to_string')) # Start of librdf_model_transaction_start `librdf_model_transaction_start` = function(model, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_model_transaction_start', model, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_transaction_start`, 'returnType') = 'integer' attr(`librdf_model_transaction_start`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_model_transaction_start`) = c("SWIGFunction", class('librdf_model_transaction_start')) # Start of librdf_model_transaction_commit `librdf_model_transaction_commit` = function(model, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_model_transaction_commit', model, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_transaction_commit`, 'returnType') = 'integer' attr(`librdf_model_transaction_commit`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_model_transaction_commit`) = c("SWIGFunction", class('librdf_model_transaction_commit')) # Start of librdf_model_transaction_rollback `librdf_model_transaction_rollback` = function(model, .copy = FALSE) { if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_model_transaction_rollback', model, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_model_transaction_rollback`, 'returnType') = 'integer' attr(`librdf_model_transaction_rollback`, "inputTypes") = c('_p_librdf_model_s') class(`librdf_model_transaction_rollback`) = c("SWIGFunction", class('librdf_model_transaction_rollback')) # Start of librdf_new_storage `librdf_new_storage` = function(world, storage_name, name, options_string) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") storage_name = as(storage_name, "character"); name = as(name, "character"); options_string = as(options_string, "character"); ;ans = .Call('R_swig_librdf_new_storage', world, storage_name, name, options_string, PACKAGE='redland'); ans <- new("_p_librdf_storage_s", ref=ans) ; ans } attr(`librdf_new_storage`, 'returnType') = '_p_librdf_storage_s' attr(`librdf_new_storage`, "inputTypes") = c('_p_librdf_world_s', 'character', 'character', 'character') class(`librdf_new_storage`) = c("SWIGFunction", class('librdf_new_storage')) # Start of librdf_new_storage_from_storage `librdf_new_storage_from_storage` = function(old_storage) { if (inherits(old_storage, "ExternalReference")) old_storage = slot(old_storage,"ref") ;ans = .Call('R_swig_librdf_new_storage_from_storage', old_storage, PACKAGE='redland'); ans <- new("_p_librdf_storage_s", ref=ans) ; ans } attr(`librdf_new_storage_from_storage`, 'returnType') = '_p_librdf_storage_s' attr(`librdf_new_storage_from_storage`, "inputTypes") = c('_p_librdf_storage_s') class(`librdf_new_storage_from_storage`) = c("SWIGFunction", class('librdf_new_storage_from_storage')) # Start of librdf_free_storage `librdf_free_storage` = function(storage) { if (inherits(storage, "ExternalReference")) storage = slot(storage,"ref") ;.Call('R_swig_librdf_free_storage', storage, PACKAGE='redland'); } attr(`librdf_free_storage`, 'returnType') = 'void' attr(`librdf_free_storage`, "inputTypes") = c('_p_librdf_storage_s') class(`librdf_free_storage`) = c("SWIGFunction", class('librdf_free_storage')) # Start of librdf_parser_check_name `librdf_parser_check_name` = function(world, name, .copy = FALSE) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); ;.Call('R_swig_librdf_parser_check_name', world, name, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_parser_check_name`, 'returnType') = 'integer' attr(`librdf_parser_check_name`, "inputTypes") = c('_p_librdf_world_s', 'character') class(`librdf_parser_check_name`) = c("SWIGFunction", class('librdf_parser_check_name')) # Start of librdf_new_parser `librdf_new_parser` = function(world, name, mime_type, type_uri) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); mime_type = as(mime_type, "character"); if (inherits(type_uri, "ExternalReference")) type_uri = slot(type_uri,"ref") ;ans = .Call('R_swig_librdf_new_parser', world, name, mime_type, type_uri, PACKAGE='redland'); ans <- new("_p_librdf_parser_s", ref=ans) ; ans } attr(`librdf_new_parser`, 'returnType') = '_p_librdf_parser_s' attr(`librdf_new_parser`, "inputTypes") = c('_p_librdf_world_s', 'character', 'character', '_p_librdf_uri_s') class(`librdf_new_parser`) = c("SWIGFunction", class('librdf_new_parser')) # Start of librdf_free_parser `librdf_free_parser` = function(parser) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") ;.Call('R_swig_librdf_free_parser', parser, PACKAGE='redland'); } attr(`librdf_free_parser`, 'returnType') = 'void' attr(`librdf_free_parser`, "inputTypes") = c('_p_librdf_parser_s') class(`librdf_free_parser`) = c("SWIGFunction", class('librdf_free_parser')) # Start of librdf_parser_parse_as_stream `librdf_parser_parse_as_stream` = function(parser, uri, inUriorNull) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") if (inherits(inUriorNull, "ExternalReference")) inUriorNull = slot(inUriorNull,"ref") ;ans = .Call('R_swig_librdf_parser_parse_as_stream', parser, uri, inUriorNull, PACKAGE='redland'); ans <- new("_p_librdf_stream_s", ref=ans) ; ans } attr(`librdf_parser_parse_as_stream`, 'returnType') = '_p_librdf_stream_s' attr(`librdf_parser_parse_as_stream`, "inputTypes") = c('_p_librdf_parser_s', '_p_librdf_uri_s', '_p_librdf_uri_s') class(`librdf_parser_parse_as_stream`) = c("SWIGFunction", class('librdf_parser_parse_as_stream')) # Start of librdf_parser_parse_into_model `librdf_parser_parse_into_model` = function(parser, uri, inUriOrNull, model, .copy = FALSE) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") if (inherits(inUriOrNull, "ExternalReference")) inUriOrNull = slot(inUriOrNull,"ref") if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_parser_parse_into_model', parser, uri, inUriOrNull, model, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_parser_parse_into_model`, 'returnType') = 'integer' attr(`librdf_parser_parse_into_model`, "inputTypes") = c('_p_librdf_parser_s', '_p_librdf_uri_s', '_p_librdf_uri_s', '_p_librdf_model_s') class(`librdf_parser_parse_into_model`) = c("SWIGFunction", class('librdf_parser_parse_into_model')) # Start of librdf_parser_parse_string_as_stream `librdf_parser_parse_string_as_stream` = function(parser, string, base_uri) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") string = as(string, "character"); if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") ;ans = .Call('R_swig_librdf_parser_parse_string_as_stream', parser, string, base_uri, PACKAGE='redland'); ans <- new("_p_librdf_stream_s", ref=ans) ; ans } attr(`librdf_parser_parse_string_as_stream`, 'returnType') = '_p_librdf_stream_s' attr(`librdf_parser_parse_string_as_stream`, "inputTypes") = c('_p_librdf_parser_s', 'character', '_p_librdf_uri_s') class(`librdf_parser_parse_string_as_stream`) = c("SWIGFunction", class('librdf_parser_parse_string_as_stream')) # Start of librdf_parser_parse_string_into_model `librdf_parser_parse_string_into_model` = function(parser, string, base_uri, model, .copy = FALSE) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") string = as(string, "character"); if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_parser_parse_string_into_model', parser, string, base_uri, model, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_parser_parse_string_into_model`, 'returnType') = 'integer' attr(`librdf_parser_parse_string_into_model`, "inputTypes") = c('_p_librdf_parser_s', 'character', '_p_librdf_uri_s', '_p_librdf_model_s') class(`librdf_parser_parse_string_into_model`) = c("SWIGFunction", class('librdf_parser_parse_string_into_model')) # Start of librdf_parser_parse_counted_string_as_stream `librdf_parser_parse_counted_string_as_stream` = function(parser, string, length, base_uri) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") string = as(string, "character"); length = as.integer(length); if(length(length) > 1) { warning("using only the first element of length"); }; if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") ;ans = .Call('R_swig_librdf_parser_parse_counted_string_as_stream', parser, string, length, base_uri, PACKAGE='redland'); ans <- new("_p_librdf_stream_s", ref=ans) ; ans } attr(`librdf_parser_parse_counted_string_as_stream`, 'returnType') = '_p_librdf_stream_s' attr(`librdf_parser_parse_counted_string_as_stream`, "inputTypes") = c('_p_librdf_parser_s', 'character', 'integer', '_p_librdf_uri_s') class(`librdf_parser_parse_counted_string_as_stream`) = c("SWIGFunction", class('librdf_parser_parse_counted_string_as_stream')) # Start of librdf_parser_parse_counted_string_into_model `librdf_parser_parse_counted_string_into_model` = function(parser, string, length, base_uri, model, .copy = FALSE) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") string = as(string, "character"); length = as.integer(length); if(length(length) > 1) { warning("using only the first element of length"); }; if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_parser_parse_counted_string_into_model', parser, string, length, base_uri, model, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_parser_parse_counted_string_into_model`, 'returnType') = 'integer' attr(`librdf_parser_parse_counted_string_into_model`, "inputTypes") = c('_p_librdf_parser_s', 'character', 'integer', '_p_librdf_uri_s', '_p_librdf_model_s') class(`librdf_parser_parse_counted_string_into_model`) = c("SWIGFunction", class('librdf_parser_parse_counted_string_into_model')) # Start of librdf_parser_get_feature `librdf_parser_get_feature` = function(parser, feature) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") if (inherits(feature, "ExternalReference")) feature = slot(feature,"ref") ;ans = .Call('R_swig_librdf_parser_get_feature', parser, feature, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_parser_get_feature`, 'returnType') = '_p_librdf_node_s' attr(`librdf_parser_get_feature`, "inputTypes") = c('_p_librdf_parser_s', '_p_librdf_uri_s') class(`librdf_parser_get_feature`) = c("SWIGFunction", class('librdf_parser_get_feature')) # Start of librdf_parser_set_feature `librdf_parser_set_feature` = function(parser, feature, value, .copy = FALSE) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") if (inherits(feature, "ExternalReference")) feature = slot(feature,"ref") if (inherits(value, "ExternalReference")) value = slot(value,"ref") ;.Call('R_swig_librdf_parser_set_feature', parser, feature, value, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_parser_set_feature`, 'returnType') = 'integer' attr(`librdf_parser_set_feature`, "inputTypes") = c('_p_librdf_parser_s', '_p_librdf_uri_s', '_p_librdf_node_s') class(`librdf_parser_set_feature`) = c("SWIGFunction", class('librdf_parser_set_feature')) # Start of librdf_parser_guess_name2 `librdf_parser_guess_name2` = function(world, mime_type, buffer, identifier) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") mime_type = as(mime_type, "character"); buffer = as(buffer, "character"); identifier = as(identifier, "character"); ;.Call('R_swig_librdf_parser_guess_name2', world, mime_type, buffer, identifier, PACKAGE='redland'); } attr(`librdf_parser_guess_name2`, 'returnType') = 'character' attr(`librdf_parser_guess_name2`, "inputTypes") = c('_p_librdf_world_s', 'character', 'character', 'character') class(`librdf_parser_guess_name2`) = c("SWIGFunction", class('librdf_parser_guess_name2')) # Start of librdf_parser_get_namespaces_seen_prefix `librdf_parser_get_namespaces_seen_prefix` = function(parser, offset) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") offset = as.integer(offset); if(length(offset) > 1) { warning("using only the first element of offset"); }; ;.Call('R_swig_librdf_parser_get_namespaces_seen_prefix', parser, offset, PACKAGE='redland'); } attr(`librdf_parser_get_namespaces_seen_prefix`, 'returnType') = 'character' attr(`librdf_parser_get_namespaces_seen_prefix`, "inputTypes") = c('_p_librdf_parser_s', 'integer') class(`librdf_parser_get_namespaces_seen_prefix`) = c("SWIGFunction", class('librdf_parser_get_namespaces_seen_prefix')) # Start of librdf_parser_get_namespaces_seen_uri `librdf_parser_get_namespaces_seen_uri` = function(parser, offset) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") offset = as.integer(offset); if(length(offset) > 1) { warning("using only the first element of offset"); }; ;ans = .Call('R_swig_librdf_parser_get_namespaces_seen_uri', parser, offset, PACKAGE='redland'); ans <- new("_p_librdf_uri_s", ref=ans) ; ans } attr(`librdf_parser_get_namespaces_seen_uri`, 'returnType') = '_p_librdf_uri_s' attr(`librdf_parser_get_namespaces_seen_uri`, "inputTypes") = c('_p_librdf_parser_s', 'integer') class(`librdf_parser_get_namespaces_seen_uri`) = c("SWIGFunction", class('librdf_parser_get_namespaces_seen_uri')) # Start of librdf_parser_get_namespaces_seen_count `librdf_parser_get_namespaces_seen_count` = function(parser, .copy = FALSE) { if (inherits(parser, "ExternalReference")) parser = slot(parser,"ref") ;.Call('R_swig_librdf_parser_get_namespaces_seen_count', parser, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_parser_get_namespaces_seen_count`, 'returnType') = 'integer' attr(`librdf_parser_get_namespaces_seen_count`, "inputTypes") = c('_p_librdf_parser_s') class(`librdf_parser_get_namespaces_seen_count`) = c("SWIGFunction", class('librdf_parser_get_namespaces_seen_count')) # Start of librdf_new_query `librdf_new_query` = function(world, name, uri, query_string, base_uri) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); if (inherits(uri, "ExternalReference")) uri = slot(uri,"ref") query_string = as(query_string, "character"); if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") ;ans = .Call('R_swig_librdf_new_query', world, name, uri, query_string, base_uri, PACKAGE='redland'); ans <- new("_p_librdf_query", ref=ans) ; ans } attr(`librdf_new_query`, 'returnType') = '_p_librdf_query' attr(`librdf_new_query`, "inputTypes") = c('_p_librdf_world_s', 'character', '_p_librdf_uri_s', 'character', '_p_librdf_uri_s') class(`librdf_new_query`) = c("SWIGFunction", class('librdf_new_query')) # Start of librdf_new_query_from_query `librdf_new_query_from_query` = function(old_query) { if (inherits(old_query, "ExternalReference")) old_query = slot(old_query,"ref") ;ans = .Call('R_swig_librdf_new_query_from_query', old_query, PACKAGE='redland'); ans <- new("_p_librdf_query", ref=ans) ; ans } attr(`librdf_new_query_from_query`, 'returnType') = '_p_librdf_query' attr(`librdf_new_query_from_query`, "inputTypes") = c('_p_librdf_query') class(`librdf_new_query_from_query`) = c("SWIGFunction", class('librdf_new_query_from_query')) # Start of librdf_free_query `librdf_free_query` = function(query) { if (inherits(query, "ExternalReference")) query = slot(query,"ref") ;.Call('R_swig_librdf_free_query', query, PACKAGE='redland'); } attr(`librdf_free_query`, 'returnType') = 'void' attr(`librdf_free_query`, "inputTypes") = c('_p_librdf_query') class(`librdf_free_query`) = c("SWIGFunction", class('librdf_free_query')) # Start of librdf_query_execute `librdf_query_execute` = function(query, model) { if (inherits(query, "ExternalReference")) query = slot(query,"ref") if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;ans = .Call('R_swig_librdf_query_execute', query, model, PACKAGE='redland'); ans <- new("_p_librdf_query_results", ref=ans) ; ans } attr(`librdf_query_execute`, 'returnType') = '_p_librdf_query_results' attr(`librdf_query_execute`, "inputTypes") = c('_p_librdf_query', '_p_librdf_model_s') class(`librdf_query_execute`) = c("SWIGFunction", class('librdf_query_execute')) # Start of librdf_query_get_limit `librdf_query_get_limit` = function(query, .copy = FALSE) { if (inherits(query, "ExternalReference")) query = slot(query,"ref") ;.Call('R_swig_librdf_query_get_limit', query, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_get_limit`, 'returnType') = 'integer' attr(`librdf_query_get_limit`, "inputTypes") = c('_p_librdf_query') class(`librdf_query_get_limit`) = c("SWIGFunction", class('librdf_query_get_limit')) # Start of librdf_query_set_limit `librdf_query_set_limit` = function(query, limit, .copy = FALSE) { if (inherits(query, "ExternalReference")) query = slot(query,"ref") limit = as.integer(limit); if(length(limit) > 1) { warning("using only the first element of limit"); }; ;.Call('R_swig_librdf_query_set_limit', query, limit, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_set_limit`, 'returnType') = 'integer' attr(`librdf_query_set_limit`, "inputTypes") = c('_p_librdf_query', 'integer') class(`librdf_query_set_limit`) = c("SWIGFunction", class('librdf_query_set_limit')) # Start of librdf_query_get_offset `librdf_query_get_offset` = function(query, .copy = FALSE) { if (inherits(query, "ExternalReference")) query = slot(query,"ref") ;.Call('R_swig_librdf_query_get_offset', query, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_get_offset`, 'returnType') = 'integer' attr(`librdf_query_get_offset`, "inputTypes") = c('_p_librdf_query') class(`librdf_query_get_offset`) = c("SWIGFunction", class('librdf_query_get_offset')) # Start of librdf_query_set_offset `librdf_query_set_offset` = function(query, offset, .copy = FALSE) { if (inherits(query, "ExternalReference")) query = slot(query,"ref") offset = as.integer(offset); if(length(offset) > 1) { warning("using only the first element of offset"); }; ;.Call('R_swig_librdf_query_set_offset', query, offset, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_set_offset`, 'returnType') = 'integer' attr(`librdf_query_set_offset`, "inputTypes") = c('_p_librdf_query', 'integer') class(`librdf_query_set_offset`) = c("SWIGFunction", class('librdf_query_set_offset')) # Start of librdf_query_results_as_stream `librdf_query_results_as_stream` = function(query_results) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;ans = .Call('R_swig_librdf_query_results_as_stream', query_results, PACKAGE='redland'); ans <- new("_p_librdf_stream_s", ref=ans) ; ans } attr(`librdf_query_results_as_stream`, 'returnType') = '_p_librdf_stream_s' attr(`librdf_query_results_as_stream`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_as_stream`) = c("SWIGFunction", class('librdf_query_results_as_stream')) # Start of librdf_query_results_get_count `librdf_query_results_get_count` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_get_count', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_get_count`, 'returnType') = 'integer' attr(`librdf_query_results_get_count`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_get_count`) = c("SWIGFunction", class('librdf_query_results_get_count')) # Start of librdf_query_results_next `librdf_query_results_next` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_next', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_next`, 'returnType') = 'integer' attr(`librdf_query_results_next`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_next`) = c("SWIGFunction", class('librdf_query_results_next')) # Start of librdf_query_results_finished `librdf_query_results_finished` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_finished', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_finished`, 'returnType') = 'integer' attr(`librdf_query_results_finished`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_finished`) = c("SWIGFunction", class('librdf_query_results_finished')) # Start of librdf_query_results_get_binding_value `librdf_query_results_get_binding_value` = function(query_results, offset) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") offset = as.integer(offset); if(length(offset) > 1) { warning("using only the first element of offset"); }; ;ans = .Call('R_swig_librdf_query_results_get_binding_value', query_results, offset, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_query_results_get_binding_value`, 'returnType') = '_p_librdf_node_s' attr(`librdf_query_results_get_binding_value`, "inputTypes") = c('_p_librdf_query_results', 'integer') class(`librdf_query_results_get_binding_value`) = c("SWIGFunction", class('librdf_query_results_get_binding_value')) # Start of librdf_query_results_get_binding_name `librdf_query_results_get_binding_name` = function(query_results, offset) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") offset = as.integer(offset); if(length(offset) > 1) { warning("using only the first element of offset"); }; ;.Call('R_swig_librdf_query_results_get_binding_name', query_results, offset, PACKAGE='redland'); } attr(`librdf_query_results_get_binding_name`, 'returnType') = 'character' attr(`librdf_query_results_get_binding_name`, "inputTypes") = c('_p_librdf_query_results', 'integer') class(`librdf_query_results_get_binding_name`) = c("SWIGFunction", class('librdf_query_results_get_binding_name')) # Start of librdf_query_results_get_binding_value_by_name `librdf_query_results_get_binding_value_by_name` = function(query_results, name) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") name = as(name, "character"); ;ans = .Call('R_swig_librdf_query_results_get_binding_value_by_name', query_results, name, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_query_results_get_binding_value_by_name`, 'returnType') = '_p_librdf_node_s' attr(`librdf_query_results_get_binding_value_by_name`, "inputTypes") = c('_p_librdf_query_results', 'character') class(`librdf_query_results_get_binding_value_by_name`) = c("SWIGFunction", class('librdf_query_results_get_binding_value_by_name')) # Start of librdf_query_results_get_bindings_count `librdf_query_results_get_bindings_count` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_get_bindings_count', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_get_bindings_count`, 'returnType') = 'integer' attr(`librdf_query_results_get_bindings_count`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_get_bindings_count`) = c("SWIGFunction", class('librdf_query_results_get_bindings_count')) # Start of librdf_query_results_to_file2 `librdf_query_results_to_file2` = function(query_results, name, mime_type, format_uri, base_uri, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") name = as(name, "character"); mime_type = as(mime_type, "character"); if (inherits(format_uri, "ExternalReference")) format_uri = slot(format_uri,"ref") if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") ;.Call('R_swig_librdf_query_results_to_file2', query_results, name, mime_type, format_uri, base_uri, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_to_file2`, 'returnType') = 'integer' attr(`librdf_query_results_to_file2`, "inputTypes") = c('_p_librdf_query_results', 'character', 'character', '_p_librdf_uri_s', '_p_librdf_uri_s') class(`librdf_query_results_to_file2`) = c("SWIGFunction", class('librdf_query_results_to_file2')) # Start of librdf_query_results_to_string2 `librdf_query_results_to_string2` = function(query_results, name, mime_type, format_uri, base_uri) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") name = as(name, "character"); mime_type = as(mime_type, "character"); if (inherits(format_uri, "ExternalReference")) format_uri = slot(format_uri,"ref") if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") ;.Call('R_swig_librdf_query_results_to_string2', query_results, name, mime_type, format_uri, base_uri, PACKAGE='redland'); } attr(`librdf_query_results_to_string2`, 'returnType') = 'character' attr(`librdf_query_results_to_string2`, "inputTypes") = c('_p_librdf_query_results', 'character', 'character', '_p_librdf_uri_s', '_p_librdf_uri_s') class(`librdf_query_results_to_string2`) = c("SWIGFunction", class('librdf_query_results_to_string2')) # Start of librdf_free_query_results `librdf_free_query_results` = function(query_results) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_free_query_results', query_results, PACKAGE='redland'); } attr(`librdf_free_query_results`, 'returnType') = 'void' attr(`librdf_free_query_results`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_free_query_results`) = c("SWIGFunction", class('librdf_free_query_results')) # Start of librdf_query_results_is_bindings `librdf_query_results_is_bindings` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_is_bindings', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_is_bindings`, 'returnType') = 'integer' attr(`librdf_query_results_is_bindings`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_is_bindings`) = c("SWIGFunction", class('librdf_query_results_is_bindings')) # Start of librdf_query_results_is_boolean `librdf_query_results_is_boolean` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_is_boolean', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_is_boolean`, 'returnType') = 'integer' attr(`librdf_query_results_is_boolean`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_is_boolean`) = c("SWIGFunction", class('librdf_query_results_is_boolean')) # Start of librdf_query_results_is_graph `librdf_query_results_is_graph` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_is_graph', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_is_graph`, 'returnType') = 'integer' attr(`librdf_query_results_is_graph`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_is_graph`) = c("SWIGFunction", class('librdf_query_results_is_graph')) # Start of librdf_query_results_is_syntax `librdf_query_results_is_syntax` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_is_syntax', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_is_syntax`, 'returnType') = 'integer' attr(`librdf_query_results_is_syntax`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_is_syntax`) = c("SWIGFunction", class('librdf_query_results_is_syntax')) # Start of librdf_query_results_get_boolean `librdf_query_results_get_boolean` = function(query_results, .copy = FALSE) { if (inherits(query_results, "ExternalReference")) query_results = slot(query_results,"ref") ;.Call('R_swig_librdf_query_results_get_boolean', query_results, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_query_results_get_boolean`, 'returnType') = 'integer' attr(`librdf_query_results_get_boolean`, "inputTypes") = c('_p_librdf_query_results') class(`librdf_query_results_get_boolean`) = c("SWIGFunction", class('librdf_query_results_get_boolean')) # Start of librdf_serializer_check_name `librdf_serializer_check_name` = function(world, name, .copy = FALSE) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); ;.Call('R_swig_librdf_serializer_check_name', world, name, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_serializer_check_name`, 'returnType') = 'integer' attr(`librdf_serializer_check_name`, "inputTypes") = c('_p_librdf_world_s', 'character') class(`librdf_serializer_check_name`) = c("SWIGFunction", class('librdf_serializer_check_name')) # Start of librdf_new_serializer `librdf_new_serializer` = function(world, name, mime_type, type_uri) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") name = as(name, "character"); mime_type = as(mime_type, "character"); if (inherits(type_uri, "ExternalReference")) type_uri = slot(type_uri,"ref") ;ans = .Call('R_swig_librdf_new_serializer', world, name, mime_type, type_uri, PACKAGE='redland'); ans <- new("_p_librdf_serializer_s", ref=ans) ; ans } attr(`librdf_new_serializer`, 'returnType') = '_p_librdf_serializer_s' attr(`librdf_new_serializer`, "inputTypes") = c('_p_librdf_world_s', 'character', 'character', '_p_librdf_uri_s') class(`librdf_new_serializer`) = c("SWIGFunction", class('librdf_new_serializer')) # Start of librdf_free_serializer `librdf_free_serializer` = function(serializer) { if (inherits(serializer, "ExternalReference")) serializer = slot(serializer,"ref") ;.Call('R_swig_librdf_free_serializer', serializer, PACKAGE='redland'); } attr(`librdf_free_serializer`, 'returnType') = 'void' attr(`librdf_free_serializer`, "inputTypes") = c('_p_librdf_serializer_s') class(`librdf_free_serializer`) = c("SWIGFunction", class('librdf_free_serializer')) # Start of librdf_serializer_serialize_stream_to_file `librdf_serializer_serialize_stream_to_file` = function(serializer, name, base_uri, stream, .copy = FALSE) { if (inherits(serializer, "ExternalReference")) serializer = slot(serializer,"ref") name = as(name, "character"); if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") if (inherits(stream, "ExternalReference")) stream = slot(stream,"ref") ;.Call('R_swig_librdf_serializer_serialize_stream_to_file', serializer, name, base_uri, stream, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_serializer_serialize_stream_to_file`, 'returnType') = 'integer' attr(`librdf_serializer_serialize_stream_to_file`, "inputTypes") = c('_p_librdf_serializer_s', 'character', '_p_librdf_uri_s', '_p_librdf_stream_s') class(`librdf_serializer_serialize_stream_to_file`) = c("SWIGFunction", class('librdf_serializer_serialize_stream_to_file')) # Start of librdf_serializer_serialize_model_to_file `librdf_serializer_serialize_model_to_file` = function(serializer, name, inUriOrNull, model, .copy = FALSE) { if (inherits(serializer, "ExternalReference")) serializer = slot(serializer,"ref") name = as(name, "character"); if (inherits(inUriOrNull, "ExternalReference")) inUriOrNull = slot(inUriOrNull,"ref") if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_serializer_serialize_model_to_file', serializer, name, inUriOrNull, model, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_serializer_serialize_model_to_file`, 'returnType') = 'integer' attr(`librdf_serializer_serialize_model_to_file`, "inputTypes") = c('_p_librdf_serializer_s', 'character', '_p_librdf_uri_s', '_p_librdf_model_s') class(`librdf_serializer_serialize_model_to_file`) = c("SWIGFunction", class('librdf_serializer_serialize_model_to_file')) # Start of librdf_serializer_serialize_stream_to_string `librdf_serializer_serialize_stream_to_string` = function(serializer, base_uri, stream) { if (inherits(serializer, "ExternalReference")) serializer = slot(serializer,"ref") if (inherits(base_uri, "ExternalReference")) base_uri = slot(base_uri,"ref") if (inherits(stream, "ExternalReference")) stream = slot(stream,"ref") ;.Call('R_swig_librdf_serializer_serialize_stream_to_string', serializer, base_uri, stream, PACKAGE='redland'); } attr(`librdf_serializer_serialize_stream_to_string`, 'returnType') = 'character' attr(`librdf_serializer_serialize_stream_to_string`, "inputTypes") = c('_p_librdf_serializer_s', '_p_librdf_uri_s', '_p_librdf_stream_s') class(`librdf_serializer_serialize_stream_to_string`) = c("SWIGFunction", class('librdf_serializer_serialize_stream_to_string')) # Start of librdf_serializer_serialize_model_to_string `librdf_serializer_serialize_model_to_string` = function(serializer, inUriOrNull, model) { if (inherits(serializer, "ExternalReference")) serializer = slot(serializer,"ref") if (inherits(inUriOrNull, "ExternalReference")) inUriOrNull = slot(inUriOrNull,"ref") if (inherits(model, "ExternalReference")) model = slot(model,"ref") ;.Call('R_swig_librdf_serializer_serialize_model_to_string', serializer, inUriOrNull, model, PACKAGE='redland'); } attr(`librdf_serializer_serialize_model_to_string`, 'returnType') = 'character' attr(`librdf_serializer_serialize_model_to_string`, "inputTypes") = c('_p_librdf_serializer_s', '_p_librdf_uri_s', '_p_librdf_model_s') class(`librdf_serializer_serialize_model_to_string`) = c("SWIGFunction", class('librdf_serializer_serialize_model_to_string')) # Start of librdf_serializer_get_feature `librdf_serializer_get_feature` = function(serializer, feature) { if (inherits(serializer, "ExternalReference")) serializer = slot(serializer,"ref") if (inherits(feature, "ExternalReference")) feature = slot(feature,"ref") ;ans = .Call('R_swig_librdf_serializer_get_feature', serializer, feature, PACKAGE='redland'); ans <- new("_p_librdf_node_s", ref=ans) ; ans } attr(`librdf_serializer_get_feature`, 'returnType') = '_p_librdf_node_s' attr(`librdf_serializer_get_feature`, "inputTypes") = c('_p_librdf_serializer_s', '_p_librdf_uri_s') class(`librdf_serializer_get_feature`) = c("SWIGFunction", class('librdf_serializer_get_feature')) # Start of librdf_serializer_set_feature `librdf_serializer_set_feature` = function(serializer, feature, value, .copy = FALSE) { if (inherits(serializer, "ExternalReference")) serializer = slot(serializer,"ref") if (inherits(feature, "ExternalReference")) feature = slot(feature,"ref") if (inherits(value, "ExternalReference")) value = slot(value,"ref") ;.Call('R_swig_librdf_serializer_set_feature', serializer, feature, value, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_serializer_set_feature`, 'returnType') = 'integer' attr(`librdf_serializer_set_feature`, "inputTypes") = c('_p_librdf_serializer_s', '_p_librdf_uri_s', '_p_librdf_node_s') class(`librdf_serializer_set_feature`) = c("SWIGFunction", class('librdf_serializer_set_feature')) # Start of librdf_serializer_set_namespace `librdf_serializer_set_namespace` = function(serializer, nspace, prefix, .copy = FALSE) { if (inherits(serializer, "ExternalReference")) serializer = slot(serializer,"ref") if (inherits(nspace, "ExternalReference")) nspace = slot(nspace,"ref") prefix = as(prefix, "character"); ;.Call('R_swig_librdf_serializer_set_namespace', serializer, nspace, prefix, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_serializer_set_namespace`, 'returnType') = 'integer' attr(`librdf_serializer_set_namespace`, "inputTypes") = c('_p_librdf_serializer_s', '_p_librdf_uri_s', 'character') class(`librdf_serializer_set_namespace`) = c("SWIGFunction", class('librdf_serializer_set_namespace')) # Start of librdf_free_stream `librdf_free_stream` = function(stream) { if (inherits(stream, "ExternalReference")) stream = slot(stream,"ref") ;.Call('R_swig_librdf_free_stream', stream, PACKAGE='redland'); } attr(`librdf_free_stream`, 'returnType') = 'void' attr(`librdf_free_stream`, "inputTypes") = c('_p_librdf_stream_s') class(`librdf_free_stream`) = c("SWIGFunction", class('librdf_free_stream')) # Start of librdf_stream_end `librdf_stream_end` = function(stream, .copy = FALSE) { if (inherits(stream, "ExternalReference")) stream = slot(stream,"ref") ;.Call('R_swig_librdf_stream_end', stream, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_stream_end`, 'returnType') = 'integer' attr(`librdf_stream_end`, "inputTypes") = c('_p_librdf_stream_s') class(`librdf_stream_end`) = c("SWIGFunction", class('librdf_stream_end')) # Start of librdf_stream_next `librdf_stream_next` = function(stream, .copy = FALSE) { if (inherits(stream, "ExternalReference")) stream = slot(stream,"ref") ;.Call('R_swig_librdf_stream_next', stream, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_stream_next`, 'returnType') = 'integer' attr(`librdf_stream_next`, "inputTypes") = c('_p_librdf_stream_s') class(`librdf_stream_next`) = c("SWIGFunction", class('librdf_stream_next')) # Start of librdf_stream_get_object `librdf_stream_get_object` = function(stream) { if (inherits(stream, "ExternalReference")) stream = slot(stream,"ref") ;ans = .Call('R_swig_librdf_stream_get_object', stream, PACKAGE='redland'); ans <- new("_p_librdf_statement_s", ref=ans) ; ans } attr(`librdf_stream_get_object`, 'returnType') = '_p_librdf_statement_s' attr(`librdf_stream_get_object`, "inputTypes") = c('_p_librdf_stream_s') class(`librdf_stream_get_object`) = c("SWIGFunction", class('librdf_stream_get_object')) # Start of librdf_log_message_code `librdf_log_message_code` = function(message, .copy = FALSE) { if (inherits(message, "ExternalReference")) message = slot(message,"ref") ;.Call('R_swig_librdf_log_message_code', message, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_log_message_code`, 'returnType') = 'integer' attr(`librdf_log_message_code`, "inputTypes") = c('_p_librdf_log_message') class(`librdf_log_message_code`) = c("SWIGFunction", class('librdf_log_message_code')) # Start of librdf_log_message_level `librdf_log_message_level` = function(message, .copy = FALSE) { if (inherits(message, "ExternalReference")) message = slot(message,"ref") ;.Call('R_swig_librdf_log_message_level', message, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_log_message_level`, 'returnType') = 'integer' attr(`librdf_log_message_level`, "inputTypes") = c('_p_librdf_log_message') class(`librdf_log_message_level`) = c("SWIGFunction", class('librdf_log_message_level')) # Start of librdf_log_message_facility `librdf_log_message_facility` = function(message, .copy = FALSE) { if (inherits(message, "ExternalReference")) message = slot(message,"ref") ;.Call('R_swig_librdf_log_message_facility', message, as.logical(.copy), PACKAGE='redland'); } attr(`librdf_log_message_facility`, 'returnType') = 'integer' attr(`librdf_log_message_facility`, "inputTypes") = c('_p_librdf_log_message') class(`librdf_log_message_facility`) = c("SWIGFunction", class('librdf_log_message_facility')) # Start of librdf_log_message_message `librdf_log_message_message` = function(message) { if (inherits(message, "ExternalReference")) message = slot(message,"ref") ;.Call('R_swig_librdf_log_message_message', message, PACKAGE='redland'); } attr(`librdf_log_message_message`, 'returnType') = 'character' attr(`librdf_log_message_message`, "inputTypes") = c('_p_librdf_log_message') class(`librdf_log_message_message`) = c("SWIGFunction", class('librdf_log_message_message')) # Start of librdf_log_message_locator `librdf_log_message_locator` = function(message) { if (inherits(message, "ExternalReference")) message = slot(message,"ref") ;ans = .Call('R_swig_librdf_log_message_locator', message, PACKAGE='redland'); ans <- new("_p_raptor_locator", ref=ans) ; ans } attr(`librdf_log_message_locator`, 'returnType') = '_p_raptor_locator' attr(`librdf_log_message_locator`, "inputTypes") = c('_p_librdf_log_message') class(`librdf_log_message_locator`) = c("SWIGFunction", class('librdf_log_message_locator')) # Start of raptor_locator_line `raptor_locator_line` = function(locator, .copy = FALSE) { if (inherits(locator, "ExternalReference")) locator = slot(locator,"ref") ;.Call('R_swig_raptor_locator_line', locator, as.logical(.copy), PACKAGE='redland'); } attr(`raptor_locator_line`, 'returnType') = 'integer' attr(`raptor_locator_line`, "inputTypes") = c('_p_raptor_locator') class(`raptor_locator_line`) = c("SWIGFunction", class('raptor_locator_line')) # Start of raptor_locator_column `raptor_locator_column` = function(locator, .copy = FALSE) { if (inherits(locator, "ExternalReference")) locator = slot(locator,"ref") ;.Call('R_swig_raptor_locator_column', locator, as.logical(.copy), PACKAGE='redland'); } attr(`raptor_locator_column`, 'returnType') = 'integer' attr(`raptor_locator_column`, "inputTypes") = c('_p_raptor_locator') class(`raptor_locator_column`) = c("SWIGFunction", class('raptor_locator_column')) # Start of raptor_locator_byte `raptor_locator_byte` = function(locator, .copy = FALSE) { if (inherits(locator, "ExternalReference")) locator = slot(locator,"ref") ;.Call('R_swig_raptor_locator_byte', locator, as.logical(.copy), PACKAGE='redland'); } attr(`raptor_locator_byte`, 'returnType') = 'integer' attr(`raptor_locator_byte`, "inputTypes") = c('_p_raptor_locator') class(`raptor_locator_byte`) = c("SWIGFunction", class('raptor_locator_byte')) # Start of raptor_locator_file `raptor_locator_file` = function(locator) { if (inherits(locator, "ExternalReference")) locator = slot(locator,"ref") ;.Call('R_swig_raptor_locator_file', locator, PACKAGE='redland'); } attr(`raptor_locator_file`, 'returnType') = 'character' attr(`raptor_locator_file`, "inputTypes") = c('_p_raptor_locator') class(`raptor_locator_file`) = c("SWIGFunction", class('raptor_locator_file')) # Start of raptor_locator_uri `raptor_locator_uri` = function(locator) { if (inherits(locator, "ExternalReference")) locator = slot(locator,"ref") ;.Call('R_swig_raptor_locator_uri', locator, PACKAGE='redland'); } attr(`raptor_locator_uri`, 'returnType') = 'character' attr(`raptor_locator_uri`, "inputTypes") = c('_p_raptor_locator') class(`raptor_locator_uri`) = c("SWIGFunction", class('raptor_locator_uri')) # Start of librdf_internal_test_error `librdf_internal_test_error` = function(world) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") ;.Call('R_swig_librdf_internal_test_error', world, PACKAGE='redland'); } attr(`librdf_internal_test_error`, 'returnType') = 'void' attr(`librdf_internal_test_error`, "inputTypes") = c('_p_librdf_world_s') class(`librdf_internal_test_error`) = c("SWIGFunction", class('librdf_internal_test_error')) # Start of librdf_internal_test_warning `librdf_internal_test_warning` = function(world) { if (inherits(world, "ExternalReference")) world = slot(world,"ref") ;.Call('R_swig_librdf_internal_test_warning', world, PACKAGE='redland'); } attr(`librdf_internal_test_warning`, 'returnType') = 'void' attr(`librdf_internal_test_warning`, "inputTypes") = c('_p_librdf_world_s') class(`librdf_internal_test_warning`) = c("SWIGFunction", class('librdf_internal_test_warning')) # Start of librdf_short_copyright_string_get `librdf_short_copyright_string_get` = function(.copy = FALSE) { ;.Call('R_swig_librdf_short_copyright_string_get', as.logical(.copy), PACKAGE='redland'); } attr(`librdf_short_copyright_string_get`, 'returnType') = 'character' class(`librdf_short_copyright_string_get`) = c("SWIGFunction", class('librdf_short_copyright_string_get')) librdf_short_copyright_string = librdf_short_copyright_string_get # Start of librdf_copyright_string_get `librdf_copyright_string_get` = function(.copy = FALSE) { ;.Call('R_swig_librdf_copyright_string_get', as.logical(.copy), PACKAGE='redland'); } attr(`librdf_copyright_string_get`, 'returnType') = 'character' class(`librdf_copyright_string_get`) = c("SWIGFunction", class('librdf_copyright_string_get')) librdf_copyright_string = librdf_copyright_string_get # Start of librdf_version_string_get `librdf_version_string_get` = function(.copy = FALSE) { ;.Call('R_swig_librdf_version_string_get', as.logical(.copy), PACKAGE='redland'); } attr(`librdf_version_string_get`, 'returnType') = 'character' class(`librdf_version_string_get`) = c("SWIGFunction", class('librdf_version_string_get')) librdf_version_string = librdf_version_string_get # Start of librdf_version_major_get `librdf_version_major_get` = function(.copy = FALSE) { ;.Call('R_swig_librdf_version_major_get', as.logical(.copy), PACKAGE='redland'); } attr(`librdf_version_major_get`, 'returnType') = 'integer' class(`librdf_version_major_get`) = c("SWIGFunction", class('librdf_version_major_get')) librdf_version_major = librdf_version_major_get # Start of librdf_version_minor_get `librdf_version_minor_get` = function(.copy = FALSE) { ;.Call('R_swig_librdf_version_minor_get', as.logical(.copy), PACKAGE='redland'); } attr(`librdf_version_minor_get`, 'returnType') = 'integer' class(`librdf_version_minor_get`) = c("SWIGFunction", class('librdf_version_minor_get')) librdf_version_minor = librdf_version_minor_get # Start of librdf_version_release_get `librdf_version_release_get` = function(.copy = FALSE) { ;.Call('R_swig_librdf_version_release_get', as.logical(.copy), PACKAGE='redland'); } attr(`librdf_version_release_get`, 'returnType') = 'integer' class(`librdf_version_release_get`) = c("SWIGFunction", class('librdf_version_release_get')) librdf_version_release = librdf_version_release_get # Start of librdf_version_decimal_get `librdf_version_decimal_get` = function(.copy = FALSE) { ;.Call('R_swig_librdf_version_decimal_get', as.logical(.copy), PACKAGE='redland'); } attr(`librdf_version_decimal_get`, 'returnType') = 'integer' class(`librdf_version_decimal_get`) = c("SWIGFunction", class('librdf_version_decimal_get')) librdf_version_decimal = librdf_version_decimal_get # Start of raptor_version_string_get `raptor_version_string_get` = function(.copy = FALSE) { ;.Call('R_swig_raptor_version_string_get', as.logical(.copy), PACKAGE='redland'); } attr(`raptor_version_string_get`, 'returnType') = 'character' class(`raptor_version_string_get`) = c("SWIGFunction", class('raptor_version_string_get')) raptor_version_string = raptor_version_string_get # Start of raptor_version_major_get `raptor_version_major_get` = function(.copy = FALSE) { ;.Call('R_swig_raptor_version_major_get', as.logical(.copy), PACKAGE='redland'); } attr(`raptor_version_major_get`, 'returnType') = 'integer' class(`raptor_version_major_get`) = c("SWIGFunction", class('raptor_version_major_get')) raptor_version_major = raptor_version_major_get # Start of raptor_version_minor_get `raptor_version_minor_get` = function(.copy = FALSE) { ;.Call('R_swig_raptor_version_minor_get', as.logical(.copy), PACKAGE='redland'); } attr(`raptor_version_minor_get`, 'returnType') = 'integer' class(`raptor_version_minor_get`) = c("SWIGFunction", class('raptor_version_minor_get')) raptor_version_minor = raptor_version_minor_get # Start of raptor_version_release_get `raptor_version_release_get` = function(.copy = FALSE) { ;.Call('R_swig_raptor_version_release_get', as.logical(.copy), PACKAGE='redland'); } attr(`raptor_version_release_get`, 'returnType') = 'integer' class(`raptor_version_release_get`) = c("SWIGFunction", class('raptor_version_release_get')) raptor_version_release = raptor_version_release_get # Start of raptor_version_decimal_get `raptor_version_decimal_get` = function(.copy = FALSE) { ;.Call('R_swig_raptor_version_decimal_get', as.logical(.copy), PACKAGE='redland'); } attr(`raptor_version_decimal_get`, 'returnType') = 'integer' class(`raptor_version_decimal_get`) = c("SWIGFunction", class('raptor_version_decimal_get')) raptor_version_decimal = raptor_version_decimal_get # Start of rasqal_version_string_get `rasqal_version_string_get` = function(.copy = FALSE) { ;.Call('R_swig_rasqal_version_string_get', as.logical(.copy), PACKAGE='redland'); } attr(`rasqal_version_string_get`, 'returnType') = 'character' class(`rasqal_version_string_get`) = c("SWIGFunction", class('rasqal_version_string_get')) rasqal_version_string = rasqal_version_string_get # Start of rasqal_version_major_get `rasqal_version_major_get` = function(.copy = FALSE) { ;.Call('R_swig_rasqal_version_major_get', as.logical(.copy), PACKAGE='redland'); } attr(`rasqal_version_major_get`, 'returnType') = 'integer' class(`rasqal_version_major_get`) = c("SWIGFunction", class('rasqal_version_major_get')) rasqal_version_major = rasqal_version_major_get # Start of rasqal_version_minor_get `rasqal_version_minor_get` = function(.copy = FALSE) { ;.Call('R_swig_rasqal_version_minor_get', as.logical(.copy), PACKAGE='redland'); } attr(`rasqal_version_minor_get`, 'returnType') = 'integer' class(`rasqal_version_minor_get`) = c("SWIGFunction", class('rasqal_version_minor_get')) rasqal_version_minor = rasqal_version_minor_get # Start of rasqal_version_release_get `rasqal_version_release_get` = function(.copy = FALSE) { ;.Call('R_swig_rasqal_version_release_get', as.logical(.copy), PACKAGE='redland'); } attr(`rasqal_version_release_get`, 'returnType') = 'integer' class(`rasqal_version_release_get`) = c("SWIGFunction", class('rasqal_version_release_get')) rasqal_version_release = rasqal_version_release_get # Start of rasqal_version_decimal_get `rasqal_version_decimal_get` = function(.copy = FALSE) { ;.Call('R_swig_rasqal_version_decimal_get', as.logical(.copy), PACKAGE='redland'); } attr(`rasqal_version_decimal_get`, 'returnType') = 'integer' class(`rasqal_version_decimal_get`) = c("SWIGFunction", class('rasqal_version_decimal_get')) rasqal_version_decimal = rasqal_version_decimal_get setClass('_p_librdf_query', contains = 'ExternalReference') setClass('_p_librdf_query_results', contains = 'ExternalReference') redland/R/Serializer.R0000644000176200001440000001623114566244056014337 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' @title An RDF Serializer object. #' @description The Serializer class provides methods to convert a Model object #' to other forms, for example, write out a Model to a file. #' @slot librdf_serializer A redland statement object #' @rdname Serializer-class #' @aliases Serializer #' @include redland.R #' @include World.R #' @include Model.R #' @keywords classes #' @export #' @section Methods: #' \itemize{ #' \code{\link{Serializer-initialize}}: Initialize a Serializer object. #' \code{\link{setNameSpace}}: Set a namespace for the serializer. #' \code{\link{serializeToCharacter}}: Serialize a model to a character vector. #' \code{\link{serializeToFile}}: Serialize a model to a file. #' \code{\link{freeSerializer}}: Free memory used by a librdf serializer. #' } #' @seealso \code{\link{redland}}: redland package #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' filePath <- system.file("extdata/example.rdf", package="redland") #' parser <- new("Parser", world) #' parseFileIntoModel(parser, world, filePath, model) #' # Creat the default "rdfxml" serizlizer #' serializer <- new("Serializer", world) #' # Add a namespace definition to the serializer #' status <- setNameSpace(serializer, world, namespace="http://purl.org/dc/elements/1.1/", prefix="dc") #' rdf <- serializeToCharacter(serializer, world, model, baseUri="") setClass("Serializer", slots = c(librdf_serializer = "_p_librdf_serializer_s")) #' Construct a Serializer object. #' @rdname Serializer-initialize #' @aliases Serializer-initialize #' @param .Object the Serializer object #' @param world a World object #' @param name name of a previously created serializer factory to use #' @param mimeType a mime type of the syntax of the model #' @param typeUri a URI for the syntax of the model #' @return the Serializer object #' @export setMethod("initialize", signature = "Serializer", definition = function(.Object, world, name="rdfxml", mimeType="application/rdf+xml", typeUri=as.character(NA)) { # Ensure that all provided params are not null stopifnot(!is.null(world)) if(is.na(typeUri)) { librdf_uri <- NULL } else { librdf_uri <- librdf_new_uri(world@librdf_world, typeUri) } # Create the underlying redland statement object .Object@librdf_serializer <- librdf_new_serializer(world@librdf_world, name, mimeType, librdf_uri); return(.Object) }) #' Set a namespace for the serializer. #' @rdname setNameSpace #' @param .Object a Serializer object #' @param world a World object #' @param namespace the namespace to add to the serializer #' @param prefix the namespace prefix to associate with the namespace #' @export setGeneric("setNameSpace", function(.Object, world, namespace, prefix) { standardGeneric("setNameSpace") }) #' @rdname setNameSpace setMethod("setNameSpace", signature("Serializer", "World", "character", "character"), function(.Object, world, namespace, prefix) { stopifnot(!is.null(world)) librdf_uri <- librdf_new_uri(world@librdf_world, namespace) librdf_serializer_set_namespace(.Object@librdf_serializer, librdf_uri, prefix) }) #' Serialize a model to a character vector. #' @rdname serializeToCharacter #' @param .Object a Serializer object #' @param world a World object #' @param model a Model object #' @param ... Additional parameters #' @return a character vector containing the serialized model #' @export setGeneric("serializeToCharacter", function(.Object, world, model, ...) { standardGeneric("serializeToCharacter") }) #' @rdname serializeToCharacter #' @param baseUri a URI to prepend to relative URIs in the document setMethod("serializeToCharacter", signature("Serializer", "World", "Model"), function(.Object, world, model, baseUri=as.character(NA)) { stopifnot(!is.null(world)) stopifnot(!is.null(model)) # Convert baseUri to a librdf_uri if(is.na(baseUri)) { librdf_uri <- NULL } else { librdf_uri <- librdf_new_uri(world@librdf_world, baseUri) } RDFstring <- librdf_serializer_serialize_model_to_string(.Object@librdf_serializer, librdf_uri, model@librdf_model) return(RDFstring) }) #' Serialize a model to a file. #' @rdname serializeToFile #' @param .Object a Serializer object #' @param world a World object #' @param model a Model object #' @param filePath a file path that the serialized model will be written to #' @param ... Additional parameters #' @return an integer containing the return status where non zero indicates an error occurred during serialization #' @export setGeneric("serializeToFile", function(.Object, world, model, filePath, ...) { standardGeneric("serializeToFile") }) #' @rdname serializeToFile #' @param baseUri a base URI to use for the serialization setMethod("serializeToFile", signature("Serializer", "World", "Model", "character"), function(.Object, world, model, filePath, baseUri=as.character(NA)) { stopifnot(!is.null(world)) stopifnot(!is.null(model)) stopifnot(!is.null(filePath)) # Convert baseUri to a librdf_uri if(is.na(baseUri)) { librdf_uri <- NULL } else { librdf_uri <- librdf_new_uri(world@librdf_world, baseUri) } status <-librdf_serializer_serialize_model_to_file (.Object@librdf_serializer, filePath, librdf_uri, model@librdf_model); return(status) }) #' Free memory used by a librdf serializer. #' @rdname freeSerializer #' @param .Object a Serializer object #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' filePath <- system.file("extdata/example.rdf", package="redland") #' parser <- new("Parser", world) #' parseFileIntoModel(parser, world, filePath, model) #' # Creat the default "rdfxml" serizlizer #' serializer <- new("Serializer", world) #' # At this point, some operations would be performed with the Serializer object. #' # See '?Serializer' for a complete example. #' # When the serializer object is no longer needed, the resources it had allocated can be freed. #' freeSerializer(serializer) #' rm(serializer) #' @export setGeneric("freeSerializer", function(.Object) { standardGeneric("freeSerializer") }) #' @rdname freeSerializer setMethod("freeSerializer", signature("Serializer"), function(.Object) { librdf_free_serializer(.Object@librdf_serializer) }) redland/R/Model.R0000644000176200001440000001000614566244056013260 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. #' @title A Redland Model object #' @description A Model object is used to store the statements (triples) of an RDF model. #' @details A Model may be created manually by creating \code{\link{Statement}} and adding #' them to the Model using \code{\link{addStatement}}, or a Model may be read in from a #' previously saved file using \code{\link{parseFileIntoModel}}. Once a Model is created, #' it can be queried using \code{\link{Query}}. #' @seealso View examples of creating models by viewing the \code{'redland_overview'} vignette: \code{'vignette("redland_overview")'} #' @slot librdf_model A redland model object #' @rdname Model-class #' @aliases Model #' @include redland.R #' @include World.R #' @include Storage.R #' @include Statement.R #' @keywords classes #' @section Methods: #' \itemize{ #' \code{\link{Model-initialize}}: Initialize a Model object #' \code{\link{addStatement}}: Add a Statement object to the Model #' \code{\link{freeModel}}: Free memory used by a librdf model object #' } #' @seealso \code{\link{redland}}: redland package #' @export #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") setClass("Model", slots=c(librdf_model = "_p_librdf_model_s")) #' Constructor for a Model object. #' @param .Object a Node object #' @param world a World object #' @param storage a Storage object #' @param options extra options for model initialization #' @rdname Model-initialize #' @aliases Model-initialize #' @return the World object #' @export setMethod("initialize", signature = "Model", definition = function(.Object, world, storage, options) { stopifnot(!is.null(world), !is.null(storage)) .Object@librdf_model <- librdf_new_model(world@librdf_world, storage@librdf_storage, options); return(.Object) }) #' Add a Statement object to the Model #' @rdname addStatement #' @param .Object a Model object #' @param statement the Statement that will be added #' @export #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") setGeneric("addStatement", function(.Object, statement) { standardGeneric("addStatement") }) #' @rdname addStatement setMethod("addStatement", signature("Model", "Statement"), function(.Object, statement) { librdf_model_add_statement(.Object@librdf_model, statement@librdf_statement); }) #' Free memory used by a librdf model. #' @rdname freeModel #' @details After this method is called, the Model object is no longer usable and should #' be deleted \code{"rm(model)"} and a new object created. #' @param .Object a Model object #' @export #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' # At this point, some operations would be performed with the model. #' # See '?redland' for a complete example. #' # When the Model object is no longer needed, the resources it has allocated can be freed. #' freeModel(model) #' rm(model) setGeneric("freeModel", function(.Object) { standardGeneric("freeModel") }) #' @rdname freeModel setMethod("freeModel", signature("Model"), function(.Object) { librdf_free_model(.Object@librdf_model) }) redland/R/Query.R0000644000176200001440000002777414566244056013351 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' @title Query an RDF model #' @description The Query class is used to execute a query on a Model object using the default query #' language SPARQL. For more information, please refer to \url{https://librdf.org/rasqal/} for details on #' supported query languages. #' @details A Query is executed using the executeQuery method, which returns a QueryResults object that #' can be iterated over the query solution sequence. #' @slot librdf_query A redland query object #' @slot librdf_world A redland world object #' @rdname Query-class #' @aliases Query #' @include redland.R #' @keywords classes #' @export #' @references www.example.com #' @section Methods: #' \itemize{ #' \code{\link{Query-initialize}}: Initialize a Query object. #' \code{\link{executeQuery}}: Execute a query. #' \code{\link{setQueryResultLimit}}: Set limit on returned query results. #' \code{\link{getQueryResultLimit}}: Get the query result limit. #' \code{\link{getResults}}: Return all query results. #' \code{\link{writeResults}}: Write query results to a file. #' \code{\link{freeParser}}: Free memory used by a librdf query. #' } #' @seealso \code{\link{redland}}: redland package #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' stmt <- new("Statement", world=world, #' subject="https://cn.dataone.org/cn/v1/resolve/urn:uuid:274a0c5c-3082-4562-bbd3-2b1288768cac", #' predicate="http://www.w3.org/ns/prov#hadPlan", #' object="https://cn.dataone.org/cn/v1/resolve/urn:uuid:01305f45-f22b-40c8-8d27-00357d01e4a5") #' status <- addStatement(model, stmt) #' stmt <- new("Statement", world=world, #' subject="https://orcid.org/0000-0002-2192-403X", #' predicate="http://www.w3.org/ns/prov#Agent", #' object="slaughter", #' objectType="literal", #' datatype_uri="http://www.w3.org/2001/XMLSchema#string") #' status <- addStatement(model, stmt) #' queryString <- #' paste("PREFIX orcid: ", #' "PREFIX dataone: ", #' "PREFIX prov: ", #' "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") #' query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) #' # Return all results as a string #' results <- getResults(query, model, "rdfxml") #' setClass("Query", slots = c(librdf_query = "_p_librdf_query", librdf_world = "_p_librdf_world_s")) #' Initialize the Query object. #' @rdname Query-initialize #' @aliases Query-initialize #' @param .Object the Query object #' @param world a World object #' @param querystring a query string for the language specified in 'query_language' #' @param base_uri a URI to prepend to relative URI in the document #' @param query_language the query language to execute the querystring with #' @param query_uri a URI to prepend to terms in the query #' @return the Query object #' @export setMethod("initialize", signature = "Query", definition = function(.Object, world, querystring, base_uri=NULL, query_language="sparql", query_uri=NULL) { stopifnot(!is.null(querystring)) .Object@librdf_query <- librdf_new_query(world@librdf_world, query_language, base_uri, querystring, query_uri) .Object@librdf_world <- world@librdf_world return(.Object) }) #' Execute a query #' @description The initialize query is executed and the result is returned as a QueryResult object #' @rdname executeQuery #' @param .Object a Query object #' @param model a Model object containing the statements to query #' @return a QueryResults object #' @export setGeneric("executeQuery", function(.Object, model) { standardGeneric("executeQuery") }) #' @rdname executeQuery setMethod("executeQuery", signature("Query"), function(.Object, model) { results <- librdf_query_execute(.Object@librdf_query, model@librdf_model) queryResultObj <- new("QueryResults", results) return(queryResultObj) }) #' Set limit on returned query results #' @rdname setQueryResultsLimit #' @aliases setQueryResultsLimit #' @param .Object a Query object #' @param limit the result set limit. Specify a value >= to have a limit, or a value < 0 to have no limit. #' @export setGeneric("setQueryResultLimit", function(.Object, limit) { standardGeneric("setQueryResultLimit") }) #' @rdname setQueryResultsLimit setMethod("setQueryResultLimit", signature("Query"), function(.Object, limit) { librdf_query_set_limit(.Object@librdf_query, as.integer(limit)) }) #' Get the query result limit #' @rdname getQueryResultsLimit #' @param .Object a Query object #' @return the query result limit. If a limit is set then the value will be >= 0. If the value is < 0, no limit is set #' @export setGeneric("getQueryResultLimit", function(.Object) { standardGeneric("getQueryResultLimit") }) #' @rdname getQueryResultsLimit setMethod("getQueryResultLimit", signature("Query"), function(.Object) { return(librdf_query_get_limit (.Object@librdf_query)) }) #' Return all query results #' @details After this method is called, the Query object is no longer usable and should #' be deleted \code{"rm(query)"} and a new object created. #' @rdname getResults #' @param .Object a Query object #' @param model a Model object #' @param formatName a string specifying the RDF format name. Currently the supported formats are "rdfxml" ,"turtle", "json", "csv" #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' stmt <- new("Statement", world=world, #' subject="https://orcid.org/0000-0002-2192-403X", #' predicate="http://www.w3.org/ns/prov#Agent", #' object="slaughter", #' objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") #' #objectType="literal", language="en") #' status <- addStatement(model, stmt) #' queryString <- paste("PREFIX orcid: ", #' "PREFIX dataone: ", #' "PREFIX prov: ", #' "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") #' query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) #' # Return all results as a string #' results <- getResults(query, model, "rdfxml") #' results <- getResults(query, model, "turtle") #' results <- getResults(query, model, "json") #' #' # When the query object is no longer needed, the resources it had allocated can be freed. #' freeQuery(query) #' rm(query) #' @export #' @param ... additional parameters setGeneric("getResults", function(.Object, model, ...) { standardGeneric("getResults") }) #' @rdname getResults setMethod("getResults", signature("Query"), function(.Object, model, formatName="rdfxml") { queryResult <- executeQuery(.Object, model) if (!is.null(queryResult@librdf_query_results) && librdf_query_results_finished(queryResult@librdf_query_results) == 0) { # It appears that this redland C library function doesn't allow specifying 'formatName' as "" or NULL, so the next two # arguments can never be used. Also, a text value has to be specified for the 3rd argument (mimeType) otherwise the function crashes. if(is.null(formatName) || formatName == "") formatName="rdfxml" results <- librdf_query_results_to_string2(queryResult@librdf_query_results, formatName, "application/rdf+xml", NULL, NULL); return(results) } else { return(NULL) } }) #' Write query results to a file. #' @details After this method is called, the Query object is no longer usable and should #' be deleted \code{"rm(query)"} and a new object created. #' @rdname writeResults #' @param .Object a Query object #' @param model a Model object #' @param ... additional parameters #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' stmt <- new("Statement", world=world, #' subject="https://orcid.org/0000-0002-2192-403X", #' predicate="http://www.w3.org/ns/prov#Agent", #' object="slaughter", #' objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") #' status <- addStatement(model, stmt) #' queryString <- paste("PREFIX orcid: ", #' "PREFIX dataone: ", #' "PREFIX prov: ", #' "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") #' query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) #' # Return all results as a string #' tf <- tempfile() #' writeResults(query, model, file=tf, mimeType="application/x-turtle") #' #' # When the query object is no longer needed, the resources it had allocated can be freed. #' freeQuery(query) #' rm(query) #' @export setGeneric("writeResults", function(.Object, model, ...) { standardGeneric("writeResults") }) #' @rdname writeResults #' @param file a string specifying the output file #' @param mimeType a string specifying the mimeType of the output file. Currently supported values are "application/x-turtle", "text/plain", "application/json", "text/html" #' @param format_uri (not currently used) #' @param base_uri (not currently used) setMethod("writeResults", signature("Query"), function(.Object, model, file, mimeType="application/x-turtle", format_uri=NULL, base_uri=NULL) { queryResult <- executeQuery(.Object, model) if (!is.null(queryResult@librdf_query_results) && librdf_query_results_finished(queryResult@librdf_query_results) == 0) { results <- librdf_query_results_to_file2(queryResult@librdf_query_results, file, mimeType, format_uri, base_uri); return(results) } else { return(NULL) } }) #' Free memory used by a librdf query #' @details After this method is called, the Query object is no longer usable and should #' be deleted \code{"rm(query)"} and a new object created. #' @rdname freeQuery #' @param .Object a Query object #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' stmt <- new("Statement", world=world, #' subject="https://orcid.org/0000-0002-2192-403X", #' predicate="http://www.w3.org/ns/prov#Agent", #' object="slaughter", #' objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") #' status <- addStatement(model, stmt) #' queryString <- paste("PREFIX orcid: ", #' "PREFIX dataone: ", #' "PREFIX prov: ", #' "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") #' query <- new("Query", world, queryString, base_uri=NULL, #' query_language="sparql", query_uri=NULL) #' # Return all results as a string #' results <- getResults(query, model, "rdfxml") #' #' # When the query object is no longer needed, the resources it had allocated can be freed. #' freeQuery(query) #' rm(query) #' @export setGeneric("freeQuery", function(.Object) { standardGeneric("freeQuery") }) #' @rdname freeQuery setMethod("freeQuery", signature("Query"), function(.Object) { librdf_free_query(.Object@librdf_query) }) redland/R/util.R0000644000176200001440000000223214433104445013165 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' Determine whether an externalptr object is NULL. #' #' The pointer is treated as an externalptr and checked via a call in C to see if it is NULL. #' @param pointer externalptr to be checked for NULL value #' @return logical TRUE if the pointer is NULL, otherwise FALSE #' @export is.null.externalptr <- function(pointer) { if (!inherits(pointer, "externalptr")) stop("pointer is not an externalptr.") rv <- .Call("isnull", pointer) return(rv) } redland/R/Parser.R0000644000176200001440000001411714566244056013463 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2015 Regents of the University of California # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' @title An RDF Parser object #' @description The Parser class provides methods to parse RDF content into a Redland #' RDF model. #' @slot librdf_parser A redland parser object #' @rdname Parser-class #' @aliases Parser #' @include redland.R #' @include World.R #' @include Model.R #' @keywords classes #' @export #' @section Methods: #' \itemize{ #' \code{\link{Parser-initialize}}: Initialize a Parser object. #' \code{\link{parseFileIntoModel}}: Parse the contents of a file into a model. #' \code{\link{freeParser}}: Free memory used by a librdf parser. #' } #' @seealso \code{\link{redland}}: redland package #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' # Create the default "rdfxml" parser #' parser <- new("Parser", world) #' filePath <- system.file("extdata/example.rdf", package="redland") #' parseFileIntoModel(parser, world, filePath, model) setClass("Parser", slots = c(librdf_parser = "_p_librdf_parser_s")) #' Initialize a Parser object. #' @description A Parser object is initialized for a specific RDF serialization. #' @details The serialization format that are supported by #' @rdname Parser-initialize #' @aliases Parser-initialize #' @param .Object the Parser object #' @param world a World object #' @param name name of the parser factory to use #' @param mimeType a mime type of the syntax of the model #' @param typeUri a URI for the syntax of the model #' @return the Parser object #' @export setMethod("initialize", signature = "Parser", definition = function(.Object, world, name="rdfxml", mimeType="application/rdf+xml", typeUri=as.character(NA)) { # Ensure that all provided params are not null stopifnot(!is.null(world)) if(is.na(typeUri)) { librdf_uri <- librdf_new_uri(world@librdf_world, "") } else { librdf_uri <- librdf_new_uri(world@librdf_world, typeUri) } # Create the underlying redland statement object .Object@librdf_parser <- librdf_new_parser(world@librdf_world, name, mimeType, librdf_uri); return(.Object) }) #' Parse the contents of a file into a model #' @description The contents of a the specified file are read and parsed into the initialized #' Parser object #' @details The parser factory name specified during initialization determines how the content is #' parsed, for example, if 'rdfxml' was specified during parser initialization, then the parser #' expects RDF/XML content as specified in the W3C recommendation (http://www.we3.org/TR/REC-rdf-syntax) #' @rdname parseFileIntoModel #' @param .Object a Parser object #' @param world a World object #' @param filePath a file that contains the RDF content #' @param model a Model object to parse the RDF content into #' @param ... (Additional parameters) #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' # Create the default "rdfxml" parser #' parser <- new("Parser", world) #' filePath <- system.file("extdata/example.rdf", package="redland") #' parseFileIntoModel(parser, world, filePath, model) #' @export setGeneric("parseFileIntoModel", function(.Object, world, filePath, model, ...) { standardGeneric("parseFileIntoModel") }) #' @rdname parseFileIntoModel #' @param baseUri a base URI (i.e. XML base) to apply to the model setMethod("parseFileIntoModel", signature("Parser", "World", "character", "Model"), function(.Object, world, filePath, model, baseUri=as.character(NA)) { stopifnot(!is.null(model)) if(is.na(baseUri)) { librdf_uri <- NULL } else { librdf_uri <- librdf_new_uri(world@librdf_world, baseUri) } # Construct a file URI of the input file name err <- try(absFilePath <- normalizePath(filePath, mustWork = TRUE)) stopifnot (!class(err) == "try-error") # Absolute paths on Windows require leading slash: /C:/foo/bar if(grepl("^[a-zA-Z]:", absFilePath)) absFilePath <- paste0("/", absFilePath) fileUri = sprintf("file://%s", absFilePath) contentUri <- librdf_new_uri(world@librdf_world, fileUri) status <- librdf_parser_parse_into_model(.Object@librdf_parser, contentUri, NULL, model@librdf_model) }) #' Free memory used by a librdf parser #' @details After freeNode is called, the Node object is no longer usable and should #' be deleted \code{"rm(nodeName)"} and a new object created. #' @rdname freeParser #' @param .Object a Node object #' @examples #' world <- new("World") #' storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") #' model <- new("Model", world, storage, options="") #' parser <- new("Parser", world) #' filePath <- system.file("extdata/example.rdf", package="redland") #' parseFileIntoModel(parser, world, filePath, model) #' # At this point, some operations would be performed with the Model that has been populated #' # with the parser. #' # See '?redland' for a complete example. #' # When the parser object is no longer needed, the resources it had allocated can be freed. #' freeParser(parser) #' rm(parser) #' @export setGeneric("freeParser", function(.Object) { standardGeneric("freeParser") }) #' @rdname freeParser setMethod("freeParser", signature("Parser"), function(.Object) { librdf_free_parser(.Object@librdf_parser) }) redland/R/mergeNamespace_roclet.R0000644000176200001440000001225014433104445016475 0ustar liggesusers# # This work was created by the National Center for Ecological Analysis and Synthesis. # # Copyright 2014 # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #' A custom Roxygen roclet that adds Redland RDF functions to NAMESPACE file generated by Roxygen. #' @description The redland package uses the SWIG (Simplified Wrapper and Interface Generator) to #' create the bindings between the Redland RDF C/C++ libraries and R. SWIG creates a NAMESPACE #' file that contains the function names for the librdf wrapper that it creates, but as of #' swig 3.0.2 this NAMESPACE file is incorrect and will also be overwritten by Roxygen when #' 'roxygenize()' or 'devtools:document()' is called, as the wrapper R code doesn't contain #' Roxygen export annotations used by Roxygen to build the namespace file. #' To allow for building a NAMESPACE file from all programs in the redland package, this roclet #' determines the set of wrapper R functions and adds these to the Roxygen generated NAMESPACE file #' that contains all names from the native R code in the redland package. #' @details The following line must be present in the DESCRIPTION file for this roclet to be #' called automatically when 'roxygen2::roxygenize()' or 'devtools::document()' is called: #' #' Roxygen: list(roclets = c("collate", "rd", "namespace", "mergeNamespace_roclet")) #' #' The 'namespace' roclet must always run before the 'mergeNamespace' roclet. #' @examples #' \dontrun{ #' roxygen2::roxygenize() #' devtools::document() #' } #' @import roxygen2 #' @param x a roclet #' @param ... additional parameters #' @export mergeNamespace_roclet <- function(x, ...) { roclet("mergeNamespace") } #' Roxygen process function for the 'mergeNamespace' roclet #' @description This function is called by the Roxygen2 roxygenize function. #' @details This function loads the Redland interface file and tests each loaded function to #' see if it should be exported via the NAMESPACE file. #' @param x the currently running roclet #' @param blocks the documentation blocks #' @param env the current env #' @param base_path the top directory of the R package #' @export roclet_process.roclet_mergeNamespace <- function(x, blocks, env, base_path) { #on.exit(detach(".redland-temp")) #attach(NULL, name=".redland-temp") tmpEnv <- new.env() # Load the Redland wrapper file into a temporary environment. This file has a definition of # each redland library function that will be made available to the package. filePath <- sprintf("%s/R/redland.R", base_path) #source(filePath, as.environment(".redland-temp")) source(file=filePath, local=as.environment(tmpEnv)) # Check each Redland function to see if it has the SWIGfunction attribute set, and if so # include this function name in the list of functions to be exported #funcList <- ls(as.environment(".redland-temp")) funcList <- ls(as.environment(tmpEnv)) exportFuncList <- list() for (functionName in funcList) { funcType <- attr(get(functionName), "class")[1] if(is.null(funcType)) next if (funcType == "SWIGFunction") { exportFuncList <- c(exportFuncList, functionName) #cat(sprintf("func: %s\n", functionName)) } } rm(list=ls(tmpEnv), envir=tmpEnv) rm(tmpEnv) return(exportFuncList) } #' Roxygen output function that merges a base NAMESPACE file with the Roxygen dynamically created NAMSPACE file #' @description The 'roclet_output' function handles output of the results from the 'roc_process' function. #' This function merges the NAMESPACE file created by the 'namespace' roclet with the list of Redland RDF #' functions determined by the 'roc_process' function. #' @param x the currently running roclet #' @param results the list of items to process that was generated by the roc_process.mergedNamespace function #' @param base_path the base directory path of the package #' @param ... additional parameters #' @export roclet_output.roclet_mergeNamespace <- function(x, results, base_path, ...) { # Get contents of the NAMESPACE file that was created by the "namespace" roclet filePathNS <- file.path(base_path, "NAMESPACE") NScontents <- if (file.exists(filePathNS)) readLines(filePathNS) else "" # Merge the contents of the "namespace" roclet NAMESPACE file with the list # of functions from Redland mergedContents <- NScontents for (tm in results) { tm <- sprintf("export(%s)", tm) mergedContents <- c(mergedContents, tm) } if (identical(mergedContents, NScontents)) { warning("No functions added from Redland wrapper file.") } else { cat("Adding namespace directives for Redland library\n") writeLines(mergedContents, filePathNS) } filePathNS } #' @export roclet_tags.roclet_mergeNamespace <- function(x) { list() } redland/cleanup0000755000176200001440000000003515116115727013244 0ustar liggesusers#!/bin/sh rm -f src/Makevars redland/NEWS0000644000176200001440000000570215114726166012377 0ustar liggesusersVersion 1.0.17-19 BUG FIXES * fix package-level docs to generate alias without @docType (#107) * replace SET_S4_OBJECT error in redland.c (#110) Version 1.0.17-18 BUG FIXES * Fix for ucrt on arm64 (#102) * Fix Rd documentation syntax issues * Remove trailing slash from README link for CRAN Version 1.0.17-17 BUG FIXES * fix compiler warnings that CRAN is no longer tolerating from SWIG (#100) * fix NOTE "Found if() conditions comparing class() to string" (#100) * fix Roxygen2 roclet build issues (#100) * Fix various spelling words that were flagged (#100) * Fix URLs that were reported as moved (#100) Version 1.0.17-16 BUG FIXES * Resolved package compile warnings (e.g. "-Wpointer-sign") (#96) Version 1.0.17-15 BUG FIXES * Resolved UCRT build issues for Windows builds under Rtools42 (#93) Version 1.0.17-14 BUG FIXES * Resolved CRAN check errors during config on macOS for 1.0.17-13 (#91) Version 1.0.17-13 BUG FIXES * Resolved CRAN check errors for 1.0.17-12 submission (#89) Version 1.0.17-12 BUG FIXES * Update 'configure' for OS portability (#82) NEW FEATURES * Update tests for compatibility with testthat 3e (#125) Version 1.0.17-11 BUG FIXES * Removed deprecated function warnings during package build. (#79) * Fix memory protection problems reported by 'rchk'. (#78) * Deprecate the function getNextResult(), which is superceded by getResults(). (#79) Version 1.0.17-10 BUG FIXES * The function 'statement()' now accepts an RDF language tag for literal nodes (#64) NEW FEATURES * Ability to retrieve all query results at once. (#58) * New function getNodeValue() (#65) * New function getResults() (#58) * New function writeResults() (#58) Version 1.0.17-9 BUG FIXES * Vignettes now build with R 3.4.0 and are now updated to the ./doc directory by package installation. * Added an installation cleanup script Version 1.0.17-8 NEW FEATURES * For Mac OS X, binary installations no longer require Redland system libraries to be installed, as these libraries are now statically linked into the redland package shared library 'redland.so'. BUG FIXES * Fixed an unresolved symbol problem with Windows 32 bit builds under R 3.3.0 (and gcc 4.9.3 tool chain) Version 1.0.17-7 BUG FIXES * Unit tests have been updated to be compatible with the changes in the 'testthat' package that were made in development version testthat_0.11.0.9000, and will be released to CRAN on 4/4/2016. The updated unit tests pass with both the current version of testthat (0.11.0) and the new version (0.11.0.9000). Version 1.0.17 -------------- NEW FEATURES * Initial version (see help topic for 'redland', e.g. "?redland") * Includes API wrappers for corresponding Redland 1.0.17 C library NEW S4 CLASSES * Classes Node, Statement, and Model for representing RDF * Classes Storage and World for managing collections of statements * Classes Parser and Serializer for for loading and saving models * classes Query and QueryResults for searching models using SPARQL redland/vignettes/0000755000176200001440000000000015116115726013700 5ustar liggesusersredland/vignettes/redland_overview.Rmd0000644000176200001440000000474114433104445017706 0ustar liggesusers--- title: "redland: create, query and write RDF graphs" author: "Peter Slaughter" date: "`r Sys.Date()`" output: rmarkdown::html_vignette vignette: > %\VignetteIndexEntry{redland RDF} %\VignetteEngine{knitr::rmarkdown} %\VignetteEncoding{UTF-8} --- ## Introduction The `redland` R package provides methods to create, query and write to disk data stored in the Resource Description Framework (RDF). RDF provides a standardized way to make statements about resources and the relationships between them. Typical resources include datasets that are available via URLs. Resources don't have to be available online, for example a resource could also be the name of the person that created a dataset. A collection of RDF statements comprise an RDF graph, which can be read and interpreted by an RDF capable software application that uses the resources described in the graph. An introduction to RDF can be found at https://www.w3.org/TR/2014/NOTE-rdf11-primer-20140624/. ## Examples The following example reads an RDF graph from a disk file that was previously saved in the RDF/XML format: ```{r} library(redland) world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world=world, storage, options="") parser <- new("Parser", world) parseFileIntoModel(parser, world, system.file("extdata", "dc.rdf", package="redland"), model) ``` Next the RDF graph is queried for statements of interest, using the [SPARQL query syntax](https://www.w3.org/TR/rdf-sparql-query/) ```{r} queryString <- 'PREFIX dc: SELECT ?a ?c WHERE { ?a dc:creator ?c . }' query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) queryResult <- executeQuery(query, model) results <- getResults(query, model, "rdfxml") cat(sprintf("Results from query: %s\n", results)) ``` Next, additional statements can be added to the RDF graph: ```{r} stmt <- new("Statement", world=world, subject="http://www.dajobe.org/", predicate="http://purl.org/dc/elements/1.1/language", object="en") addStatement(model, stmt) ``` Now the RDF graph can be written to disk: ```{r} serializer <- new("Serializer", world, mimeType="application/rdf+xml") status <- setNameSpace(serializer, world, namespace="http://purl.org/dc/elements/1.1/", prefix="dc") filePath <- tempfile(pattern = "file", tmpdir = tempdir(), fileext = ".rdf") status <- serializeToFile(serializer, world, model, filePath) ``` redland/src/0000755000176200001440000000000015116115726012457 5ustar liggesusersredland/src/Makevars.win0000644000176200001440000000124514156163010014741 0ustar liggesusersPKG_CPPFLAGS= -I../windows/redland-1.0.17/include \ -I../windows/redland-1.0.17/include/rasqal \ -I../windows/redland-1.0.17/include/raptor2 PKG_LIBS=-L../windows/redland-1.0.17/lib${R_ARCH}${CRT} -lrdf \ -pipe -lrasqal -lpcre -lraptor2 -lxml2 -lpcre -lz -liconv -lws2_32 ## Workaround for missing _mkgmtime on Win32, See also ## https://sourceforge.net/p/mingw-w64/bugs/473/ ifeq "${R_ARCH}" "/i386" ifeq "${R_COMPILED_BY}" "gcc 4.9.3" PKG_LIBS += -lmsvcr100 endif endif PKG_CFLAGS=-DRASQAL_STATIC -DRAPTOR_STATIC -DREDLAND_STATIC all: clean winlibs winlibs: clean "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" "../tools/winlibs.R" clean: rm -f $(OBJECTS) redland.dll redland/src/Makevars.ucrt0000644000176200001440000000036314566244056015140 0ustar liggesusersifeq (,$(shell pkg-config --libs redland)) CRT=-ucrt include Makevars.win else PKG_CPPFLAGS=-DRASQAL_STATIC -DRAPTOR_STATIC -DREDLAND_STATIC $(shell pkg-config --cflags redland) PKG_LIBS=$(shell pkg-config --libs-only-l redland) endif redland/src/util.c0000644000176200001440000000055213366717502013607 0ustar liggesusers#include #include #include SEXP isnull(SEXP pointer) { void *ptr = R_ExternalPtrAddr(pointer); SEXP rvalue = PROTECT(NEW_LOGICAL(1)); if (ptr==NULL) { LOGICAL_DATA(rvalue)[0] = (Rboolean)TRUE; } else { LOGICAL_DATA(rvalue)[0] = (Rboolean)FALSE; } UNPROTECT(1); return(rvalue); } redland/src/Makevars.in0000644000176200001440000000011212654540057014555 0ustar liggesusersPKG_CPPFLAGS=@cflags@ PKG_LIBS=@libs@ all: clean clean: rm -f *.o *.so redland/src/redland.c0000644000176200001440000103603115114715102014230 0ustar liggesusers/* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). * Version 3.0.12 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make * changes to this file unless you know what you are doing--modify the SWIG * interface file instead. * ----------------------------------------------------------------------------- */ #ifndef SWIGR #define SWIGR #endif /* ----------------------------------------------------------------------------- * This section contains generic SWIG labels for method/variable * declarations/attributes, and other compiler dependent labels. * ----------------------------------------------------------------------------- */ /* template workaround for compilers that cannot correctly implement the C++ standard */ #ifndef SWIGTEMPLATEDISAMBIGUATOR # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) # define SWIGTEMPLATEDISAMBIGUATOR template # elif defined(__HP_aCC) /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ # define SWIGTEMPLATEDISAMBIGUATOR template # else # define SWIGTEMPLATEDISAMBIGUATOR # endif #endif /* inline attribute */ #ifndef SWIGINLINE # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) # define SWIGINLINE inline # else # define SWIGINLINE # endif #endif /* attribute recognised by some compilers to avoid 'unused' warnings */ #ifndef SWIGUNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif # elif defined(__ICC) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif #endif #ifndef SWIG_MSC_UNSUPPRESS_4505 # if defined(_MSC_VER) # pragma warning(disable : 4505) /* unreferenced local function has been removed */ # endif #endif #ifndef SWIGUNUSEDPARM # ifdef __cplusplus # define SWIGUNUSEDPARM(p) # else # define SWIGUNUSEDPARM(p) p SWIGUNUSED # endif #endif /* internal SWIG method */ #ifndef SWIGINTERN # define SWIGINTERN static SWIGUNUSED #endif /* internal inline SWIG method */ #ifndef SWIGINTERNINLINE # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE #endif /* exporting methods */ #if defined(__GNUC__) # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # ifndef GCC_HASCLASSVISIBILITY # define GCC_HASCLASSVISIBILITY # endif # endif #endif #ifndef SWIGEXPORT # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # if defined(STATIC_LINKED) # define SWIGEXPORT # else # define SWIGEXPORT __declspec(dllexport) # endif # else # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) # define SWIGEXPORT __attribute__ ((visibility("default"))) # else # define SWIGEXPORT # endif # endif #endif /* calling conventions for Windows */ #ifndef SWIGSTDCALL # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # define SWIGSTDCALL __stdcall # else # define SWIGSTDCALL # endif #endif /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) # define _CRT_SECURE_NO_DEPRECATE #endif /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) # define _SCL_SECURE_NO_DEPRECATE #endif /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 #endif /* Intel's compiler complains if a variable which was never initialised is * cast to void, which is a common idiom which we use to indicate that we * are aware a variable isn't used. So we just silence that warning. * See: https://github.com/swig/swig/issues/192 for more discussion. */ #ifdef __INTEL_COMPILER # pragma warning disable 592 #endif /* ----------------------------------------------------------------------------- * swigrun.swg * * This file contains generic C API SWIG runtime support for pointer * type checking. * ----------------------------------------------------------------------------- */ /* This should only be incremented when either the layout of swig_type_info changes, or for whatever reason, the runtime changes incompatibly */ #define SWIG_RUNTIME_VERSION "4" /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ #ifdef SWIG_TYPE_TABLE # define SWIG_QUOTE_STRING(x) #x # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) #else # define SWIG_TYPE_TABLE_NAME #endif /* You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for creating a static or dynamic library from the SWIG runtime code. In 99.9% of the cases, SWIG just needs to declare them as 'static'. But only do this if strictly necessary, ie, if you have problems with your compiler or suchlike. */ #ifndef SWIGRUNTIME # define SWIGRUNTIME SWIGINTERN #endif #ifndef SWIGRUNTIMEINLINE # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE #endif /* Generic buffer size */ #ifndef SWIG_BUFFER_SIZE # define SWIG_BUFFER_SIZE 1024 #endif /* Flags for pointer conversions */ #define SWIG_POINTER_DISOWN 0x1 #define SWIG_CAST_NEW_MEMORY 0x2 /* Flags for new pointer objects */ #define SWIG_POINTER_OWN 0x1 /* Flags/methods for returning states. The SWIG conversion methods, as ConvertPtr, return an integer that tells if the conversion was successful or not. And if not, an error code can be returned (see swigerrors.swg for the codes). Use the following macros/flags to set or process the returning states. In old versions of SWIG, code such as the following was usually written: if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { // success code } else { //fail code } Now you can be more explicit: int res = SWIG_ConvertPtr(obj,vptr,ty.flags); if (SWIG_IsOK(res)) { // success code } else { // fail code } which is the same really, but now you can also do Type *ptr; int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); if (SWIG_IsOK(res)) { // success code if (SWIG_IsNewObj(res) { ... delete *ptr; } else { ... } } else { // fail code } I.e., now SWIG_ConvertPtr can return new objects and you can identify the case and take care of the deallocation. Of course that also requires SWIG_ConvertPtr to return new result values, such as int SWIG_ConvertPtr(obj, ptr,...) { if () { if () { *ptr = ; return SWIG_NEWOBJ; } else { *ptr = ; return SWIG_OLDOBJ; } } else { return SWIG_BADOBJ; } } Of course, returning the plain '0(success)/-1(fail)' still works, but you can be more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the SWIG errors code. Finally, if the SWIG_CASTRANK_MODE is enabled, the result code allows to return the 'cast rank', for example, if you have this int food(double) int fooi(int); and you call food(1) // cast rank '1' (1 -> 1.0) fooi(1) // cast rank '0' just use the SWIG_AddCast()/SWIG_CheckState() */ #define SWIG_OK (0) #define SWIG_ERROR (-1) #define SWIG_IsOK(r) (r >= 0) #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) /* The CastRankLimit says how many bits are used for the cast rank */ #define SWIG_CASTRANKLIMIT (1 << 8) /* The NewMask denotes the object was created (using new/malloc) */ #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) /* The TmpMask is for in/out typemaps that use temporal objects */ #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) /* Simple returning values */ #define SWIG_BADOBJ (SWIG_ERROR) #define SWIG_OLDOBJ (SWIG_OK) #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) /* Check, add and del mask methods */ #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) /* Cast-Rank Mode */ #if defined(SWIG_CASTRANK_MODE) # ifndef SWIG_TypeRank # define SWIG_TypeRank unsigned long # endif # ifndef SWIG_MAXCASTRANK /* Default cast allowed */ # define SWIG_MAXCASTRANK (2) # endif # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) SWIGINTERNINLINE int SWIG_AddCast(int r) { return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; } SWIGINTERNINLINE int SWIG_CheckState(int r) { return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; } #else /* no cast-rank mode */ # define SWIG_AddCast(r) (r) # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) #endif #include #ifdef __cplusplus extern "C" { #endif typedef void *(*swig_converter_func)(void *, int *); typedef struct swig_type_info *(*swig_dycast_func)(void **); /* Structure to store information on one type */ typedef struct swig_type_info { const char *name; /* mangled name of this type */ const char *str; /* human readable name of this type */ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ struct swig_cast_info *cast; /* linked list of types that can cast into this type */ void *clientdata; /* language specific type data */ int owndata; /* flag if the structure owns the clientdata */ } swig_type_info; /* Structure to store a type and conversion function used for casting */ typedef struct swig_cast_info { swig_type_info *type; /* pointer to type that is equivalent to this type */ swig_converter_func converter; /* function to cast the void pointers */ struct swig_cast_info *next; /* pointer to next cast in linked list */ struct swig_cast_info *prev; /* pointer to the previous cast */ } swig_cast_info; /* Structure used to store module information * Each module generates one structure like this, and the runtime collects * all of these structures and stores them in a circularly linked list.*/ typedef struct swig_module_info { swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ size_t size; /* Number of types in this module */ struct swig_module_info *next; /* Pointer to next element in circularly linked list */ swig_type_info **type_initial; /* Array of initially generated type structures */ swig_cast_info **cast_initial; /* Array of initially generated casting structures */ void *clientdata; /* Language specific module data */ } swig_module_info; /* Compare two type names skipping the space characters, therefore "char*" == "char *" and "Class" == "Class", etc. Return 0 when the two name types are equivalent, as in strncmp, but skipping ' '. */ SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2) { for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { while ((*f1 == ' ') && (f1 != l1)) ++f1; while ((*f2 == ' ') && (f2 != l2)) ++f2; if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; } return (int)((l1 - f1) - (l2 - f2)); } /* Check type equivalence in a name list like ||... Return 0 if equal, -1 if nb < tb, 1 if nb > tb */ SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb) { int equiv = 1; const char* te = tb + strlen(tb); const char* ne = nb; while (equiv != 0 && *ne) { for (nb = ne; *ne; ++ne) { if (*ne == '|') break; } equiv = SWIG_TypeNameComp(nb, ne, tb, te); if (*ne) ++ne; } return equiv; } /* Check type equivalence in a name list like ||... Return 0 if not equal, 1 if equal */ SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb) { return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; } /* Check the typename */ SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty) { if (ty) { swig_cast_info *iter = ty->cast; while (iter) { if (strcmp(iter->type->name, c) == 0) { if (iter == ty->cast) return iter; /* Move iter to the top of the linked list */ iter->prev->next = iter->next; if (iter->next) iter->next->prev = iter->prev; iter->next = ty->cast; iter->prev = 0; if (ty->cast) ty->cast->prev = iter; ty->cast = iter; return iter; } iter = iter->next; } } return 0; } /* Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison */ SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { if (ty) { swig_cast_info *iter = ty->cast; while (iter) { if (iter->type == from) { if (iter == ty->cast) return iter; /* Move iter to the top of the linked list */ iter->prev->next = iter->next; if (iter->next) iter->next->prev = iter->prev; iter->next = ty->cast; iter->prev = 0; if (ty->cast) ty->cast->prev = iter; ty->cast = iter; return iter; } iter = iter->next; } } return 0; } /* Cast a pointer up an inheritance hierarchy */ SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); } /* Dynamic pointer casting. Down an inheritance hierarchy */ SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { swig_type_info *lastty = ty; if (!ty || !ty->dcast) return ty; while (ty && (ty->dcast)) { ty = (*ty->dcast)(ptr); if (ty) lastty = ty; } return lastty; } /* Return the name associated with this type */ SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty) { return ty->name; } /* Return the pretty name associated with this type, that is an unmangled type name in a form presentable to the user. */ SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type) { /* The "str" field contains the equivalent pretty names of the type, separated by vertical-bar characters. We choose to print the last name, as it is often (?) the most specific. */ if (!type) return NULL; if (type->str != NULL) { const char *last_name = type->str; const char *s; for (s = type->str; *s; s++) if (*s == '|') last_name = s+1; return last_name; } else return type->name; } /* Set the clientdata field for a type */ SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { swig_cast_info *cast = ti->cast; /* if (ti->clientdata == clientdata) return; */ ti->clientdata = clientdata; while (cast) { if (!cast->converter) { swig_type_info *tc = cast->type; if (!tc->clientdata) { SWIG_TypeClientData(tc, clientdata); } } cast = cast->next; } } SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { SWIG_TypeClientData(ti, clientdata); ti->owndata = 1; } /* Search for a swig_type_info structure only by mangled name Search is a O(log #types) We start searching at module start, and finish searching when start == end. Note: if start == end at the beginning of the function, we go all the way around the circular list. */ SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name) { swig_module_info *iter = start; do { if (iter->size) { size_t l = 0; size_t r = iter->size - 1; do { /* since l+r >= 0, we can (>> 1) instead (/ 2) */ size_t i = (l + r) >> 1; const char *iname = iter->types[i]->name; if (iname) { int compare = strcmp(name, iname); if (compare == 0) { return iter->types[i]; } else if (compare < 0) { if (i) { r = i - 1; } else { break; } } else if (compare > 0) { l = i + 1; } } else { break; /* should never happen */ } } while (l <= r); } iter = iter->next; } while (iter != end); return 0; } /* Search for a swig_type_info structure for either a mangled name or a human readable name. It first searches the mangled names of the types, which is a O(log #types) If a type is not found it then searches the human readable names, which is O(#types). We start searching at module start, and finish searching when start == end. Note: if start == end at the beginning of the function, we go all the way around the circular list. */ SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name) { /* STEP 1: Search the name field using binary search */ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); if (ret) { return ret; } else { /* STEP 2: If the type hasn't been found, do a complete search of the str field (the human readable name) */ swig_module_info *iter = start; do { size_t i = 0; for (; i < iter->size; ++i) { if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) return iter->types[i]; } iter = iter->next; } while (iter != end); } /* neither found a match */ return 0; } /* Pack binary data into a string */ SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz) { static const char hex[17] = "0123456789abcdef"; const unsigned char *u = (unsigned char *) ptr; const unsigned char *eu = u + sz; for (; u != eu; ++u) { unsigned char uu = *u; *(c++) = hex[(uu & 0xf0) >> 4]; *(c++) = hex[uu & 0xf]; } return c; } /* Unpack binary data from a string */ SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) { unsigned char *u = (unsigned char *) ptr; const unsigned char *eu = u + sz; for (; u != eu; ++u) { char d = *(c++); unsigned char uu; if ((d >= '0') && (d <= '9')) uu = (unsigned char)((d - '0') << 4); else if ((d >= 'a') && (d <= 'f')) uu = (unsigned char)((d - ('a'-10)) << 4); else return (char *) 0; d = *(c++); if ((d >= '0') && (d <= '9')) uu |= (unsigned char)(d - '0'); else if ((d >= 'a') && (d <= 'f')) uu |= (unsigned char)(d - ('a'-10)); else return (char *) 0; *u = uu; } return c; } /* Pack 'void *' into a string buffer. */ SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { char *r = buff; if ((2*sizeof(void *) + 2) > bsz) return 0; *(r++) = '_'; r = SWIG_PackData(r,&ptr,sizeof(void *)); if (strlen(name) + 1 > (bsz - (r - buff))) return 0; strcpy(r,name); return buff; } SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { if (*c != '_') { if (strcmp(c,"NULL") == 0) { *ptr = (void *) 0; return name; } else { return 0; } } return SWIG_UnpackData(++c,ptr,sizeof(void *)); } SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { char *r = buff; size_t lname = (name ? strlen(name) : 0); if ((2*sz + 2 + lname) > bsz) return 0; *(r++) = '_'; r = SWIG_PackData(r,ptr,sz); if (lname) { strncpy(r,name,lname+1); } else { *r = 0; } return buff; } SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { if (*c != '_') { if (strcmp(c,"NULL") == 0) { memset(ptr,0,sz); return name; } else { return 0; } } return SWIG_UnpackData(++c,ptr,sz); } #ifdef __cplusplus } #endif /* Remove global namespace pollution */ #if !defined(SWIG_NO_R_NO_REMAP) # define R_NO_REMAP #endif #if !defined(SWIG_NO_STRICT_R_HEADERS) # define STRICT_R_HEADERS #endif #include #include #ifdef __cplusplus #include extern "C" { #endif /* for raw pointer */ #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_R_ConvertPtr(obj, pptr, type, flags) #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_R_ConvertPtr(obj, pptr, type, flags) #define SWIG_NewPointerObj(ptr, type, flags) SWIG_R_NewPointerObj(ptr, type, flags) #include #include #include #if R_VERSION >= R_Version(2,6,0) #define VMAXTYPE void * #else #define VMAXTYPE char * #endif /* This is mainly a way to avoid having lots of local variables that may conflict with those in the routine. Change name to R_SWIG_Callb.... */ typedef struct RCallbackFunctionData { SEXP fun; SEXP userData; SEXP expr; SEXP retValue; int errorOccurred; SEXP el; /* Temporary pointer used in the construction of the expression to call the R function. */ struct RCallbackFunctionData *previous; /* Stack */ } RCallbackFunctionData; static RCallbackFunctionData *callbackFunctionDataStack; SWIGRUNTIME SEXP R_SWIG_debug_getCallbackFunctionData(void) { int n, i; SEXP ans; RCallbackFunctionData *p = callbackFunctionDataStack; n = 0; while(p) { n++; p = p->previous; } Rf_protect(ans = Rf_allocVector(VECSXP, n)); for(p = callbackFunctionDataStack, i = 0; i < n; p = p->previous, i++) SET_VECTOR_ELT(ans, i, p->fun); Rf_unprotect(1); return(ans); } SWIGRUNTIME RCallbackFunctionData * R_SWIG_pushCallbackFunctionData(SEXP fun, SEXP userData) { RCallbackFunctionData *el; el = (RCallbackFunctionData *) calloc(1, sizeof(RCallbackFunctionData)); el->fun = fun; el->userData = userData; el->previous = callbackFunctionDataStack; callbackFunctionDataStack = el; return(el); } SWIGRUNTIME SEXP R_SWIG_R_pushCallbackFunctionData(SEXP fun, SEXP userData) { R_SWIG_pushCallbackFunctionData(fun, userData); return R_NilValue; } SWIGRUNTIME RCallbackFunctionData * R_SWIG_getCallbackFunctionData(void) { if(!callbackFunctionDataStack) { Rf_error("Supposedly impossible error occurred in the SWIG callback mechanism." " No callback function data set."); } return callbackFunctionDataStack; } SWIGRUNTIME void R_SWIG_popCallbackFunctionData(int doFree) { RCallbackFunctionData *el = NULL; if(!callbackFunctionDataStack) return ; /* Error !!! */ el = callbackFunctionDataStack ; callbackFunctionDataStack = callbackFunctionDataStack->previous; if(doFree) free(el); } /* Interface to S function is(obj, type) which is to be used to determine if an external pointer inherits from the right class. Ideally, we would like to be able to do this without an explicit call to the is() function. When the S4 class system uses its own SEXP types, then we will hopefully be able to do this in the C code. Should we make the expression static and preserve it to avoid the overhead of allocating each time. */ SWIGRUNTIME int R_SWIG_checkInherits(SEXP obj, SEXP tag, const char *type) { SEXP e, val; int check_err = 0; Rf_protect(e = Rf_allocVector(LANGSXP, 3)); SETCAR(e, Rf_install("extends")); SETCAR(CDR(e), Rf_mkString(CHAR(PRINTNAME(tag)))); SETCAR(CDR(CDR(e)), Rf_mkString(type)); val = R_tryEval(e, R_GlobalEnv, &check_err); Rf_unprotect(1); if(check_err) return(0); return(LOGICAL(val)[0]); } SWIGRUNTIME void * R_SWIG_resolveExternalRef(SEXP arg, const char * const type, const char * const argName, Rboolean nullOk) { void *ptr; SEXP orig = arg; if(TYPEOF(arg) != EXTPTRSXP) arg = GET_SLOT(arg, Rf_mkString("ref")); if(TYPEOF(arg) != EXTPTRSXP) { Rf_error("argument %s must be an external pointer (from an ExternalReference)", argName); } ptr = R_ExternalPtrAddr(arg); if(ptr == NULL && nullOk == (Rboolean) FALSE) { Rf_error("the external pointer (of type %s) for argument %s has value NULL", argName, type); } if(type[0] && R_ExternalPtrTag(arg) != Rf_install(type) && strcmp(type, "voidRef") && !R_SWIG_checkInherits(orig, R_ExternalPtrTag(arg), type)) { Rf_error("the external pointer for argument %s has tag %s, not the expected value %s", argName, CHAR(PRINTNAME(R_ExternalPtrTag(arg))), type); } return(ptr); } SWIGRUNTIME void R_SWIG_ReferenceFinalizer(SEXP el) { void *ptr = R_SWIG_resolveExternalRef(el, "", "", (Rboolean) 1); Rf_PrintValue(el); if(ptr) { if(TYPEOF(el) != EXTPTRSXP) el = GET_SLOT(el, Rf_mkString("ref")); if(TYPEOF(el) == EXTPTRSXP) R_ClearExternalPtr(el); free(ptr); } return; } typedef enum {R_SWIG_EXTERNAL, R_SWIG_OWNER } R_SWIG_Owner; SWIGRUNTIME SEXP SWIG_MakePtr(void *ptr, const char *typeName, R_SWIG_Owner owner) { SEXP external, r_obj; Rf_protect(external = R_MakeExternalPtr(ptr, Rf_install(typeName), R_NilValue)); Rf_protect(r_obj = NEW_OBJECT(MAKE_CLASS((char *) typeName))); if(owner) R_RegisterCFinalizer(external, R_SWIG_ReferenceFinalizer); r_obj = SET_SLOT(r_obj, Rf_mkString((char *) "ref"), external); Rf_asS4(r_obj, TRUE, FALSE); Rf_unprotect(2); return(r_obj); } SWIGRUNTIME SEXP R_SWIG_create_SWIG_R_Array(const char *typeName, SEXP ref, int len) { SEXP arr; /*XXX remove the char * cast when we can. MAKE_CLASS should be declared appropriately. */ Rf_protect(arr = NEW_OBJECT(MAKE_CLASS((char *) typeName))); Rf_protect(arr = R_do_slot_assign(arr, Rf_mkString("ref"), ref)); Rf_protect(arr = R_do_slot_assign(arr, Rf_mkString("dims"), Rf_ScalarInteger(len))); Rf_unprotect(3); Rf_asS4(arr, TRUE, FALSE); return arr; } #define ADD_OUTPUT_ARG(result, pos, value, name) r_ans = AddOutputArgToReturn(pos, value, name, OutputValues); SWIGRUNTIME SEXP AddOutputArgToReturn(int pos, SEXP value, const char *name, SEXP output) { SET_VECTOR_ELT(output, pos, value); return(output); } /* Create a new pointer object */ SWIGRUNTIMEINLINE SEXP SWIG_R_NewPointerObj(void *ptr, swig_type_info *type, int flags) { SEXP rptr = PROTECT(R_MakeExternalPtr(ptr, PROTECT(R_MakeExternalPtr(type, R_NilValue, R_NilValue)), R_NilValue)); Rf_asS4(rptr, TRUE, FALSE); UNPROTECT(2); return rptr; } /* Convert a pointer value */ SWIGRUNTIMEINLINE int SWIG_R_ConvertPtr(SEXP obj, void **ptr, swig_type_info *ty, int flags) { void *vptr; if (!obj) return SWIG_ERROR; if (obj == R_NilValue) { if (ptr) *ptr = NULL; return SWIG_OK; } vptr = R_ExternalPtrAddr(obj); if (ty) { swig_type_info *to = (swig_type_info*) R_ExternalPtrAddr(R_ExternalPtrTag(obj)); if (to == ty) { if (ptr) *ptr = vptr; } else { swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); int newmemory = 0; if (ptr) *ptr = SWIG_TypeCast(tc,vptr,&newmemory); assert(!newmemory); /* newmemory handling not yet implemented */ } } else { if (ptr) *ptr = vptr; } return SWIG_OK; } SWIGRUNTIME swig_module_info * SWIG_GetModule(void *SWIGUNUSEDPARM(clientdata)) { static void *type_pointer = (void *)0; return (swig_module_info *) type_pointer; } SWIGRUNTIME void SWIG_SetModule(void *v, swig_module_info *swig_module) { } typedef struct { void *pack; swig_type_info *ty; size_t size; } RSwigPacked; /* Create a new packed object */ SWIGRUNTIMEINLINE SEXP RSwigPacked_New(void *ptr, size_t sz, swig_type_info *ty) { SEXP rptr; RSwigPacked *sobj = (RSwigPacked*) malloc(sizeof(RSwigPacked)); if (sobj) { void *pack = malloc(sz); if (pack) { memcpy(pack, ptr, sz); sobj->pack = pack; sobj->ty = ty; sobj->size = sz; } else { sobj = 0; } } rptr = R_MakeExternalPtr(sobj, R_NilValue, R_NilValue); return rptr; } SWIGRUNTIME swig_type_info * RSwigPacked_UnpackData(SEXP obj, void *ptr, size_t size) { RSwigPacked *sobj = (RSwigPacked *)R_ExternalPtrAddr(obj); if (sobj->size != size) return 0; memcpy(ptr, sobj->pack, size); return sobj->ty; } SWIGRUNTIMEINLINE SEXP SWIG_R_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { return ptr ? RSwigPacked_New((void *) ptr, sz, type) : R_NilValue; } /* Convert a packed value value */ SWIGRUNTIME int SWIG_R_ConvertPacked(SEXP obj, void *ptr, size_t sz, swig_type_info *ty) { swig_type_info *to = RSwigPacked_UnpackData(obj, ptr, sz); if (!to) return SWIG_ERROR; if (ty) { if (to != ty) { /* check type cast? */ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); if (!tc) return SWIG_ERROR; } } return SWIG_OK; } #ifdef __cplusplus #define SWIG_exception_noreturn(code, msg) do { throw std::runtime_error(msg); } while(0) #else #define SWIG_exception_noreturn(code, msg) do { return result; } while(0) #endif #ifdef __cplusplus } #endif #define SWIG_exception_fail(code, msg) do { Rf_warning(msg); return Rf_ScalarLogical(NA_LOGICAL); return Rf_ScalarLogical(NA_LOGICAL); } while(0) #define SWIG_contract_assert(expr, msg) if (!(expr)) { Rf_warning(msg); return Rf_ScalarLogical(NA_LOGICAL); return Rf_ScalarLogical(NA_LOGICAL); } else /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_char swig_types[0] #define SWIGTYPE_p_librdf_digest_s swig_types[1] #define SWIGTYPE_p_librdf_hash_s swig_types[2] #define SWIGTYPE_p_librdf_iterator_s swig_types[3] #define SWIGTYPE_p_librdf_log_func swig_types[4] #define SWIGTYPE_p_librdf_log_message swig_types[5] #define SWIGTYPE_p_librdf_model_s swig_types[6] #define SWIGTYPE_p_librdf_node_s swig_types[7] #define SWIGTYPE_p_librdf_parser_s swig_types[8] #define SWIGTYPE_p_librdf_query swig_types[9] #define SWIGTYPE_p_librdf_query_results swig_types[10] #define SWIGTYPE_p_librdf_serializer_s swig_types[11] #define SWIGTYPE_p_librdf_statement_s swig_types[12] #define SWIGTYPE_p_librdf_storage_s swig_types[13] #define SWIGTYPE_p_librdf_stream_s swig_types[14] #define SWIGTYPE_p_librdf_uri_s swig_types[15] #define SWIGTYPE_p_librdf_world_s swig_types[16] #define SWIGTYPE_p_p_char swig_types[17] #define SWIGTYPE_p_raptor_locator swig_types[18] static swig_type_info *swig_types[20]; static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) /* -------- TYPES TABLE (END) -------- */ /* ----------------------------------------------------------------------------- * This section contains generic SWIG labels for method/variable * declarations/attributes, and other compiler dependent labels. * ----------------------------------------------------------------------------- */ /* template workaround for compilers that cannot correctly implement the C++ standard */ #ifndef SWIGTEMPLATEDISAMBIGUATOR # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) # define SWIGTEMPLATEDISAMBIGUATOR template # elif defined(__HP_aCC) /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ # define SWIGTEMPLATEDISAMBIGUATOR template # else # define SWIGTEMPLATEDISAMBIGUATOR # endif #endif /* inline attribute */ #ifndef SWIGINLINE # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) # define SWIGINLINE inline # else # define SWIGINLINE # endif #endif /* attribute recognised by some compilers to avoid 'unused' warnings */ #ifndef SWIGUNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif # elif defined(__ICC) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif #endif #ifndef SWIG_MSC_UNSUPPRESS_4505 # if defined(_MSC_VER) # pragma warning(disable : 4505) /* unreferenced local function has been removed */ # endif #endif #ifndef SWIGUNUSEDPARM # ifdef __cplusplus # define SWIGUNUSEDPARM(p) # else # define SWIGUNUSEDPARM(p) p SWIGUNUSED # endif #endif /* internal SWIG method */ #ifndef SWIGINTERN # define SWIGINTERN static SWIGUNUSED #endif /* internal inline SWIG method */ #ifndef SWIGINTERNINLINE # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE #endif /* exporting methods */ #if defined(__GNUC__) # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # ifndef GCC_HASCLASSVISIBILITY # define GCC_HASCLASSVISIBILITY # endif # endif #endif #ifndef SWIGEXPORT # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # if defined(STATIC_LINKED) # define SWIGEXPORT # else # define SWIGEXPORT __declspec(dllexport) # endif # else # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) # define SWIGEXPORT __attribute__ ((visibility("default"))) # else # define SWIGEXPORT # endif # endif #endif /* calling conventions for Windows */ #ifndef SWIGSTDCALL # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # define SWIGSTDCALL __stdcall # else # define SWIGSTDCALL # endif #endif /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) # define _CRT_SECURE_NO_DEPRECATE #endif /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) # define _SCL_SECURE_NO_DEPRECATE #endif /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 #endif /* Intel's compiler complains if a variable which was never initialised is * cast to void, which is a common idiom which we use to indicate that we * are aware a variable isn't used. So we just silence that warning. * See: https://github.com/swig/swig/issues/192 for more discussion. */ #ifdef __INTEL_COMPILER # pragma warning disable 592 #endif /* Errors in SWIG */ #define SWIG_UnknownError -1 #define SWIG_IOError -2 #define SWIG_RuntimeError -3 #define SWIG_IndexError -4 #define SWIG_TypeError -5 #define SWIG_DivisionByZero -6 #define SWIG_OverflowError -7 #define SWIG_SyntaxError -8 #define SWIG_ValueError -9 #define SWIG_SystemError -10 #define SWIG_AttributeError -11 #define SWIG_MemoryError -12 #define SWIG_NullReferenceError -13 #define SWIGVERSION 0x030012 #define SWIG_VERSION SWIGVERSION #define SWIG_as_voidptr(a) (void *)((const void *)(a)) #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) /* compile-time include (inside a % ... % block) */ #ifdef REDLAND_PRE_I #include #endif #include /* * Thanks to the patch in this Debian bug for the solution * to the crash inside vsnprintf on some architectures. * * "reuse of args inside the while(1) loop is in violation of the * specs and only happens to work by accident on other systems." * * http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=104325 */ #ifndef va_copy #ifdef __va_copy #define va_copy(dest,src) __va_copy(dest,src) #else #define va_copy(dest,src) (dest) = (src) #endif #endif /* compile-time include (inside a % ... % block) */ #ifdef REDLAND_POST_I #include #endif /* Internal prototypes */ /* FOR TESTING ERRORS ONLY - NOT PART OF API */ void librdf_internal_test_error(librdf_world *world); void librdf_internal_test_warning(librdf_world *world); /* prototypes for internal routines called below - NOT PART OF API */ void librdf_test_error(librdf_world* world, const char* message); void librdf_test_warning(librdf_world* world, const char* message); /* FOR TESTING ERRORS ONLY - NOT PART OF API */ void librdf_internal_test_error(librdf_world *world) { librdf_test_error(world, "test error message number 1."); } void librdf_internal_test_warning(librdf_world *world) { librdf_test_warning(world, "test warning message number 2."); } SWIGINTERN char * SWIG_strdup(const char *str) { char *newstr = (char *)(malloc(strlen(str) + 1)); return strcpy(newstr, str); } SWIGINTERN int SWIG_AsCharPtrAndSize(SEXP obj, char** cptr, size_t* psize, int *alloc) { if (cptr && Rf_isString(obj)) { char *cstr = (char *)(CHAR(STRING_ELT(obj, 0))); int len = strlen(cstr); if (alloc) { if (*alloc == SWIG_NEWOBJ) { *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); *alloc = SWIG_NEWOBJ; } else { *cptr = cstr; } } else { *cptr = (char *)(malloc(len + 1)); *cptr = strcpy(*cptr, cstr); } if (psize) *psize = len + 1; return SWIG_OK; } return SWIG_TypeError; } #include #if !defined(SWIG_NO_LLONG_MAX) # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) # define LLONG_MAX __LONG_LONG_MAX__ # define LLONG_MIN (-LLONG_MAX - 1LL) # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) # endif #endif SWIGINTERNINLINE int SWIG_AsVal_long (SEXP obj, long *val) { if (val) *val = Rf_asInteger(obj); return SWIG_OK; } SWIGINTERN int SWIG_AsVal_int (SEXP obj, int *val) { long v; int res = SWIG_AsVal_long (obj, &v); if (SWIG_IsOK(res)) { if ((v < INT_MIN || v > INT_MAX)) { return SWIG_OverflowError; } else { if (val) *val = (int)(v); } } return res; } SWIGINTERN SEXP SWIG_FromCharPtrAndSize(const char* carray, size_t size) { SEXP t, c; if (!carray) return R_NilValue; /* See R internals document 1.10. MkCharLen was introduced in 2.7.0. Use that instead of hand creating vector. Starting in 2.8.0 creating strings via vectors was deprecated in order to allow for use of CHARSXP caches. */ Rf_protect(t = Rf_allocVector(STRSXP, 1)); #if R_VERSION >= R_Version(2,7,0) c = Rf_mkCharLen(carray, size); #else c = Rf_allocVector(CHARSXP, size); strncpy((char *)CHAR(c), carray, size); #endif SET_STRING_ELT(t, 0, c); Rf_unprotect(1); return t; } SWIGINTERNINLINE SEXP SWIG_FromCharPtr(const char *cptr) { return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); } SWIGINTERNINLINE SEXP SWIG_From_unsigned_SS_long (unsigned long value) { return Rf_ScalarInteger((int)value); } SWIGINTERNINLINE SEXP SWIG_From_unsigned_SS_int (unsigned int value) { return SWIG_From_unsigned_SS_long (value); } #ifdef __cplusplus extern "C" { #endif SWIGEXPORT SEXP R_swig_librdf_new_digest ( SEXP world, SEXP name) { librdf_digest *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_digest" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); arg2 = (char *)(SWIG_strdup(CHAR(STRING_ELT(name, 0)))); result = (librdf_digest *)librdf_new_digest(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_digest_s, R_SWIG_OWNER | 0 ); free(arg2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_digest ( SEXP digest) { librdf_digest *arg1 = (librdf_digest *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(digest, &argp1, SWIGTYPE_p_librdf_digest_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_digest" "', argument " "1"" of type '" "librdf_digest *""'"); } arg1 = (librdf_digest *)(argp1); librdf_free_digest(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_digest_init ( SEXP digest) { librdf_digest *arg1 = (librdf_digest *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(digest, &argp1, SWIGTYPE_p_librdf_digest_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_digest_init" "', argument " "1"" of type '" "librdf_digest *""'"); } arg1 = (librdf_digest *)(argp1); librdf_digest_init(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_digest_update ( SEXP digest, SEXP buf, SEXP length) { librdf_digest *arg1 = (librdf_digest *) 0 ; char *arg2 = (char *) 0 ; size_t arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; int ecode3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(digest, &argp1, SWIGTYPE_p_librdf_digest_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_digest_update" "', argument " "1"" of type '" "librdf_digest *""'"); } arg1 = (librdf_digest *)(argp1); res2 = SWIG_AsCharPtrAndSize(buf, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_digest_update" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); ecode3 = SWIG_AsVal_int(length, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "librdf_digest_update" "', argument " "3"" of type '" "size_t""'"); } arg3 = (size_t)(val3); librdf_digest_update(arg1,(unsigned char const *)arg2,arg3); r_ans = R_NilValue; if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_digest_update_string ( SEXP digest, SEXP string) { librdf_digest *arg1 = (librdf_digest *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(digest, &argp1, SWIGTYPE_p_librdf_digest_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_digest_update_string" "', argument " "1"" of type '" "librdf_digest *""'"); } arg1 = (librdf_digest *)(argp1); res2 = SWIG_AsCharPtrAndSize(string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_digest_update_string" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); librdf_digest_update_string(arg1,(unsigned char const *)arg2); r_ans = R_NilValue; if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_digest_final ( SEXP digest) { librdf_digest *arg1 = (librdf_digest *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(digest, &argp1, SWIGTYPE_p_librdf_digest_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_digest_final" "', argument " "1"" of type '" "librdf_digest *""'"); } arg1 = (librdf_digest *)(argp1); librdf_digest_final(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_digest_to_string ( SEXP digest) { char *result = 0 ; librdf_digest *arg1 = (librdf_digest *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(digest, &argp1, SWIGTYPE_p_librdf_digest_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_digest_to_string" "', argument " "1"" of type '" "librdf_digest *""'"); } arg1 = (librdf_digest *)(argp1); result = (char *)librdf_digest_to_string(arg1); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; free((char*)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_hash ( SEXP world, SEXP name) { librdf_hash *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_hash" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_hash" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); result = (librdf_hash *)librdf_new_hash(arg1,(char const *)arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_hash_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_hash_from_string ( SEXP world, SEXP name, SEXP string) { librdf_hash *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_hash_from_string" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_hash_from_string" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_AsCharPtrAndSize(string, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_hash_from_string" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); result = (librdf_hash *)librdf_new_hash_from_string(arg1,(char const *)arg2,(char const *)arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_hash_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_hash_from_array_of_strings ( SEXP world, SEXP name, SEXP string) { librdf_hash *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; char **arg3 = (char **) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_hash_from_array_of_strings" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_hash_from_array_of_strings" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_R_ConvertPtr(string, &argp3, SWIGTYPE_p_p_char, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_hash_from_array_of_strings" "', argument " "3"" of type '" "char const **""'"); } arg3 = (char **)(argp3); result = (librdf_hash *)librdf_new_hash_from_array_of_strings(arg1,(char const *)arg2,(char const **)arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_hash_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_hash_to_string ( SEXP hash, SEXP filter) { char *result = 0 ; librdf_hash *arg1 = (librdf_hash *) 0 ; char **arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(hash, &argp1, SWIGTYPE_p_librdf_hash_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_hash_to_string" "', argument " "1"" of type '" "librdf_hash *""'"); } arg1 = (librdf_hash *)(argp1); arg2 = (char **)(SWIG_strdup(CHAR(STRING_ELT(filter, 0)))); result = (char *)librdf_hash_to_string(arg1,(char const *(*))arg2); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; free(arg2); free((char*)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_hash ( SEXP hash) { librdf_hash *arg1 = (librdf_hash *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(hash, &argp1, SWIGTYPE_p_librdf_hash_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_hash" "', argument " "1"" of type '" "librdf_hash *""'"); } arg1 = (librdf_hash *)(argp1); librdf_free_hash(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_world ( void) { librdf_world *result = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (librdf_world *)librdf_new_world(); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_world_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_world ( SEXP world) { librdf_world *arg1 = (librdf_world *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_world" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); librdf_free_world(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_world_open ( SEXP world) { librdf_world *arg1 = (librdf_world *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_world_open" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); librdf_world_open(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_world_get_feature ( SEXP world, SEXP feature) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_world_get_feature" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_R_ConvertPtr(feature, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_world_get_feature" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); result = (librdf_node *)librdf_world_get_feature(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_world_set_feature ( SEXP world, SEXP feature, SEXP value, SEXP s_swig_copy) { int result; librdf_world *arg1 = (librdf_world *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_world_set_feature" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_R_ConvertPtr(feature, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_world_set_feature" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_R_ConvertPtr(value, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_world_set_feature" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (int)librdf_world_set_feature(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_get_accept_header ( SEXP parser) { char *result = 0 ; librdf_parser *arg1 = (librdf_parser *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_get_accept_header" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); result = (char *)librdf_parser_get_accept_header(arg1); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; free((char*)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_world_set_logger ( SEXP world, SEXP user_data, SEXP log_handler) { librdf_world *arg1 = (librdf_world *) 0 ; void *arg2 = (void *) 0 ; librdf_log_func arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; void *argp3 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_world_set_logger" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_R_ConvertPtr(user_data, SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_world_set_logger" "', argument " "2"" of type '" "void *""'"); } { res3 = SWIG_R_ConvertPtr(log_handler, &argp3, SWIGTYPE_p_librdf_log_func, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_world_set_logger" "', argument " "3"" of type '" "librdf_log_func""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "librdf_world_set_logger" "', argument " "3"" of type '" "librdf_log_func""'"); } else { arg3 = *((librdf_log_func *)(argp3)); } } librdf_world_set_logger(arg1,arg2,arg3); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_iterator ( SEXP s_arg1) { librdf_iterator *arg1 = (librdf_iterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(s_arg1, &argp1, SWIGTYPE_p_librdf_iterator_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_iterator" "', argument " "1"" of type '" "librdf_iterator *""'"); } arg1 = (librdf_iterator *)(argp1); librdf_free_iterator(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_iterator_end ( SEXP iterator, SEXP s_swig_copy) { int result; librdf_iterator *arg1 = (librdf_iterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(iterator, &argp1, SWIGTYPE_p_librdf_iterator_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_iterator_end" "', argument " "1"" of type '" "librdf_iterator *""'"); } arg1 = (librdf_iterator *)(argp1); result = (int)librdf_iterator_end(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_iterator_get_object ( SEXP iterator) { librdf_node *result = 0 ; librdf_iterator *arg1 = (librdf_iterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(iterator, &argp1, SWIGTYPE_p_librdf_iterator_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_iterator_get_object" "', argument " "1"" of type '" "librdf_iterator *""'"); } arg1 = (librdf_iterator *)(argp1); result = (librdf_node *)librdf_iterator_get_object(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_iterator_get_context ( SEXP iterator) { librdf_node *result = 0 ; librdf_iterator *arg1 = (librdf_iterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(iterator, &argp1, SWIGTYPE_p_librdf_iterator_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_iterator_get_context" "', argument " "1"" of type '" "librdf_iterator *""'"); } arg1 = (librdf_iterator *)(argp1); result = (librdf_node *)librdf_iterator_get_context(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_iterator_next ( SEXP iterator, SEXP s_swig_copy) { int result; librdf_iterator *arg1 = (librdf_iterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(iterator, &argp1, SWIGTYPE_p_librdf_iterator_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_iterator_next" "', argument " "1"" of type '" "librdf_iterator *""'"); } arg1 = (librdf_iterator *)(argp1); result = (int)librdf_iterator_next(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_uri ( SEXP world, SEXP string) { librdf_uri *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_uri" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); arg2 = (char *)(SWIG_strdup(CHAR(STRING_ELT(string, 0)))); result = (librdf_uri *)librdf_new_uri(arg1,(unsigned char *)arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, R_SWIG_OWNER | 0 ); free(arg2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_uri_from_uri ( SEXP uri) { librdf_uri *result = 0 ; librdf_uri *arg1 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(uri, &argp1, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_uri_from_uri" "', argument " "1"" of type '" "librdf_uri *""'"); } arg1 = (librdf_uri *)(argp1); result = (librdf_uri *)librdf_new_uri_from_uri(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_uri_from_filename ( SEXP world, SEXP filename) { librdf_uri *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_uri_from_filename" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(filename, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_uri_from_filename" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); result = (librdf_uri *)librdf_new_uri_from_filename(arg1,(char const *)arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, R_SWIG_EXTERNAL | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_uri ( SEXP uri) { librdf_uri *arg1 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(uri, &argp1, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_uri" "', argument " "1"" of type '" "librdf_uri *""'"); } arg1 = (librdf_uri *)(argp1); librdf_free_uri(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_uri_to_string ( SEXP uri) { char *result = 0 ; librdf_uri *arg1 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(uri, &argp1, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_uri_to_string" "', argument " "1"" of type '" "librdf_uri *""'"); } arg1 = (librdf_uri *)(argp1); result = (char *)librdf_uri_to_string(arg1); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; free((char*)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_uri_equals ( SEXP first_uri, SEXP second_uri, SEXP s_swig_copy) { int result; librdf_uri *arg1 = (librdf_uri *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(first_uri, &argp1, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_uri_equals" "', argument " "1"" of type '" "librdf_uri *""'"); } arg1 = (librdf_uri *)(argp1); res2 = SWIG_R_ConvertPtr(second_uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_uri_equals" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); result = (int)librdf_uri_equals(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_uri_compare ( SEXP first_uri, SEXP second_uri, SEXP s_swig_copy) { int result; librdf_uri *arg1 = (librdf_uri *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(first_uri, &argp1, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_uri_compare" "', argument " "1"" of type '" "librdf_uri *""'"); } arg1 = (librdf_uri *)(argp1); res2 = SWIG_R_ConvertPtr(second_uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_uri_compare" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); result = (int)librdf_uri_compare(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node ( SEXP world) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); result = (librdf_node *)librdf_new_node(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node_from_uri_string ( SEXP world, SEXP string) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node_from_uri_string" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_node_from_uri_string" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); result = (librdf_node *)librdf_new_node_from_uri_string(arg1,(unsigned char const *)arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node_from_uri ( SEXP world, SEXP uri) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node_from_uri" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_R_ConvertPtr(uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_node_from_uri" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); result = (librdf_node *)librdf_new_node_from_uri(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node_from_uri_local_name ( SEXP world, SEXP uri, SEXP local_name) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; char *arg3 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node_from_uri_local_name" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_R_ConvertPtr(uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_node_from_uri_local_name" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_AsCharPtrAndSize(local_name, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_node_from_uri_local_name" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); result = (librdf_node *)librdf_new_node_from_uri_local_name(arg1,arg2,(unsigned char const *)arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node_from_normalised_uri_string ( SEXP world, SEXP uri_string, SEXP source_uri, SEXP base_uri) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; librdf_uri *arg3 = (librdf_uri *) 0 ; librdf_uri *arg4 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node_from_normalised_uri_string" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(uri_string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_node_from_normalised_uri_string" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_R_ConvertPtr(source_uri, &argp3, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_node_from_normalised_uri_string" "', argument " "3"" of type '" "librdf_uri *""'"); } arg3 = (librdf_uri *)(argp3); res4 = SWIG_R_ConvertPtr(base_uri, &argp4, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_new_node_from_normalised_uri_string" "', argument " "4"" of type '" "librdf_uri *""'"); } arg4 = (librdf_uri *)(argp4); result = (librdf_node *)librdf_new_node_from_normalised_uri_string(arg1,(unsigned char const *)arg2,arg3,arg4); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node_from_literal ( SEXP world, SEXP string, SEXP inStrOrNull, SEXP is_wf_xml) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) NULL ; int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node_from_literal" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_node_from_literal" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_AsCharPtrAndSize(inStrOrNull, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_node_from_literal" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); arg4 = (int)(INTEGER(is_wf_xml)[0]); result = (librdf_node *)librdf_new_node_from_literal(arg1,(unsigned char const *)arg2,(char const *)arg3,arg4); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node_from_typed_literal ( SEXP world, SEXP string, SEXP inStrOrNull, SEXP inUriOrNull) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) NULL ; librdf_uri *arg4 = (librdf_uri *) NULL ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node_from_typed_literal" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_node_from_typed_literal" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_AsCharPtrAndSize(inStrOrNull, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_node_from_typed_literal" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); res4 = SWIG_R_ConvertPtr(inUriOrNull, &argp4, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_new_node_from_typed_literal" "', argument " "4"" of type '" "librdf_uri *""'"); } arg4 = (librdf_uri *)(argp4); result = (librdf_node *)librdf_new_node_from_typed_literal(arg1,(unsigned char const *)arg2,(char const *)arg3,arg4); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node_from_node ( SEXP node) { librdf_node *result = 0 ; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node_from_node" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (librdf_node *)librdf_new_node_from_node(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_node_from_blank_identifier ( SEXP world, SEXP inStrOrNull) { librdf_node *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) NULL ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_node_from_blank_identifier" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(inStrOrNull, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_node_from_blank_identifier" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); result = (librdf_node *)librdf_new_node_from_blank_identifier(arg1,(unsigned char const *)arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_node ( SEXP r) { librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(r, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_node" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); librdf_free_node(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_uri ( SEXP node) { librdf_uri *result = 0 ; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_uri" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (librdf_uri *)librdf_node_get_uri(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_type ( SEXP node, SEXP s_swig_copy) { int result; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_type" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (int)librdf_node_get_type(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_literal_value ( SEXP node) { char *result = 0 ; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_literal_value" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (char *)librdf_node_get_literal_value(arg1); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_literal_value_as_latin1 ( SEXP node) { char *result = 0 ; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_literal_value_as_latin1" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (char *)librdf_node_get_literal_value_as_latin1(arg1); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_literal_value_language ( SEXP node) { char *result = 0 ; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_literal_value_language" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (char *)librdf_node_get_literal_value_language(arg1); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_literal_value_datatype_uri ( SEXP node) { librdf_uri *result = 0 ; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_literal_value_datatype_uri" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (librdf_uri *)librdf_node_get_literal_value_datatype_uri(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_literal_value_is_wf_xml ( SEXP node, SEXP s_swig_copy) { int result; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_literal_value_is_wf_xml" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (int)librdf_node_get_literal_value_is_wf_xml(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_li_ordinal ( SEXP node, SEXP s_swig_copy) { int result; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_li_ordinal" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (int)librdf_node_get_li_ordinal(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_get_blank_identifier ( SEXP node) { char *result = 0 ; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_get_blank_identifier" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (char *)librdf_node_get_blank_identifier(arg1); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_is_resource ( SEXP node, SEXP s_swig_copy) { int result; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_is_resource" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (int)librdf_node_is_resource(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_is_literal ( SEXP node, SEXP s_swig_copy) { int result; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_is_literal" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (int)librdf_node_is_literal(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_is_blank ( SEXP node, SEXP s_swig_copy) { int result; librdf_node *arg1 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_is_blank" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); result = (int)librdf_node_is_blank(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_node_equals ( SEXP first_node, SEXP second_node, SEXP s_swig_copy) { int result; librdf_node *arg1 = (librdf_node *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(first_node, &argp1, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_node_equals" "', argument " "1"" of type '" "librdf_node *""'"); } arg1 = (librdf_node *)(argp1); res2 = SWIG_R_ConvertPtr(second_node, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_node_equals" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); result = (int)librdf_node_equals(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_statement ( SEXP world) { librdf_statement *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_statement" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); result = (librdf_statement *)librdf_new_statement(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_statement_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_statement_from_statement ( SEXP statement) { librdf_statement *result = 0 ; librdf_statement *arg1 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_statement_from_statement" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); result = (librdf_statement *)librdf_new_statement_from_statement(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_statement_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_statement_from_nodes ( SEXP world, SEXP subject, SEXP predicate, SEXP object) { librdf_statement *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; librdf_node *arg4 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_statement_from_nodes" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_R_ConvertPtr(subject, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_statement_from_nodes" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(predicate, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_statement_from_nodes" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); res4 = SWIG_R_ConvertPtr(object, &argp4, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_new_statement_from_nodes" "', argument " "4"" of type '" "librdf_node *""'"); } arg4 = (librdf_node *)(argp4); result = (librdf_statement *)librdf_new_statement_from_nodes(arg1,arg2,arg3,arg4); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_statement_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_statement ( SEXP statement) { librdf_statement *arg1 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_statement" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); librdf_free_statement(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_get_subject ( SEXP statement) { librdf_node *result = 0 ; librdf_statement *arg1 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_get_subject" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); result = (librdf_node *)librdf_statement_get_subject(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_set_subject ( SEXP statement, SEXP subject) { librdf_statement *arg1 = (librdf_statement *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_set_subject" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); res2 = SWIG_R_ConvertPtr(subject, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_statement_set_subject" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); librdf_statement_set_subject(arg1,arg2); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_get_predicate ( SEXP statement) { librdf_node *result = 0 ; librdf_statement *arg1 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_get_predicate" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); result = (librdf_node *)librdf_statement_get_predicate(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_set_predicate ( SEXP statement, SEXP predicate) { librdf_statement *arg1 = (librdf_statement *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_set_predicate" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); res2 = SWIG_R_ConvertPtr(predicate, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_statement_set_predicate" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); librdf_statement_set_predicate(arg1,arg2); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_get_object ( SEXP statement) { librdf_node *result = 0 ; librdf_statement *arg1 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_get_object" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); result = (librdf_node *)librdf_statement_get_object(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_set_object ( SEXP statement, SEXP object) { librdf_statement *arg1 = (librdf_statement *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_set_object" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); res2 = SWIG_R_ConvertPtr(object, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_statement_set_object" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); librdf_statement_set_object(arg1,arg2); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_equals ( SEXP statement1, SEXP statement2, SEXP s_swig_copy) { int result; librdf_statement *arg1 = (librdf_statement *) 0 ; librdf_statement *arg2 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement1, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_equals" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); res2 = SWIG_R_ConvertPtr(statement2, &argp2, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_statement_equals" "', argument " "2"" of type '" "librdf_statement *""'"); } arg2 = (librdf_statement *)(argp2); result = (int)librdf_statement_equals(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_match ( SEXP statement, SEXP partial_statement, SEXP s_swig_copy) { int result; librdf_statement *arg1 = (librdf_statement *) 0 ; librdf_statement *arg2 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_match" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); res2 = SWIG_R_ConvertPtr(partial_statement, &argp2, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_statement_match" "', argument " "2"" of type '" "librdf_statement *""'"); } arg2 = (librdf_statement *)(argp2); result = (int)librdf_statement_match(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_statement_is_complete ( SEXP statement, SEXP s_swig_copy) { int result; librdf_statement *arg1 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(statement, &argp1, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_statement_is_complete" "', argument " "1"" of type '" "librdf_statement *""'"); } arg1 = (librdf_statement *)(argp1); result = (int)librdf_statement_is_complete(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_model ( SEXP world, SEXP storage, SEXP options_string) { librdf_model *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; librdf_storage *arg2 = (librdf_storage *) 0 ; char *arg3 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_model" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_R_ConvertPtr(storage, &argp2, SWIGTYPE_p_librdf_storage_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_model" "', argument " "2"" of type '" "librdf_storage *""'"); } arg2 = (librdf_storage *)(argp2); arg3 = (char *)(SWIG_strdup(CHAR(STRING_ELT(options_string, 0)))); result = (librdf_model *)librdf_new_model(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_model_s, R_SWIG_OWNER | 0 ); free(arg3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_model_with_options ( SEXP world, SEXP storage, SEXP options) { librdf_model *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; librdf_storage *arg2 = (librdf_storage *) 0 ; librdf_hash *arg3 = (librdf_hash *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_model_with_options" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_R_ConvertPtr(storage, &argp2, SWIGTYPE_p_librdf_storage_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_model_with_options" "', argument " "2"" of type '" "librdf_storage *""'"); } arg2 = (librdf_storage *)(argp2); res3 = SWIG_R_ConvertPtr(options, &argp3, SWIGTYPE_p_librdf_hash_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_model_with_options" "', argument " "3"" of type '" "librdf_hash *""'"); } arg3 = (librdf_hash *)(argp3); result = (librdf_model *)librdf_new_model_with_options(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_model_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_model_from_model ( SEXP model) { librdf_model *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_model_from_model" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); result = (librdf_model *)librdf_new_model_from_model(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_model_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_model ( SEXP model) { librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_model" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); librdf_free_model(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_size ( SEXP model, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_size" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); result = (int)librdf_model_size(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_add ( SEXP model, SEXP subject, SEXP predicate, SEXP object, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; librdf_node *arg4 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_add" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(subject, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_add" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(predicate, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_add" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); res4 = SWIG_R_ConvertPtr(object, &argp4, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_model_add" "', argument " "4"" of type '" "librdf_node *""'"); } arg4 = (librdf_node *)(argp4); result = (int)librdf_model_add(arg1,arg2,arg3,arg4); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_add_string_literal_statement ( SEXP model, SEXP subject, SEXP predicate, SEXP literal, SEXP inStrOrNull, SEXP is_wf_xml, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; char *arg4 = (char *) 0 ; char *arg5 = (char *) NULL ; int arg6 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; int res4 ; char *buf4 = 0 ; int alloc4 = 0 ; int res5 ; char *buf5 = 0 ; int alloc5 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_add_string_literal_statement" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(subject, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_add_string_literal_statement" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(predicate, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_add_string_literal_statement" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); res4 = SWIG_AsCharPtrAndSize(literal, &buf4, NULL, &alloc4); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_model_add_string_literal_statement" "', argument " "4"" of type '" "char const *""'"); } arg4 = (char *)(buf4); res5 = SWIG_AsCharPtrAndSize(inStrOrNull, &buf5, NULL, &alloc5); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "librdf_model_add_string_literal_statement" "', argument " "5"" of type '" "char const *""'"); } arg5 = (char *)(buf5); arg6 = (int)(INTEGER(is_wf_xml)[0]); result = (int)librdf_model_add_string_literal_statement(arg1,arg2,arg3,(unsigned char const *)arg4,(char const *)arg5,arg6); r_ans = Rf_ScalarInteger(result); if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_add_typed_literal_statement ( SEXP model, SEXP subject, SEXP predicate, SEXP string, SEXP inStrOrNull, SEXP inUriOrNull, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; char *arg4 = (char *) 0 ; char *arg5 = (char *) 0 ; librdf_uri *arg6 = (librdf_uri *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp6 = 0 ; int res6 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_add_typed_literal_statement" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(subject, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_add_typed_literal_statement" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(predicate, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_add_typed_literal_statement" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); arg4 = (char *)(SWIG_strdup(CHAR(STRING_ELT(string, 0)))); arg5 = (char *)(SWIG_strdup(CHAR(STRING_ELT(inStrOrNull, 0)))); res6 = SWIG_R_ConvertPtr(inUriOrNull, &argp6, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "librdf_model_add_typed_literal_statement" "', argument " "6"" of type '" "librdf_uri *""'"); } arg6 = (librdf_uri *)(argp6); result = (int)librdf_model_add_typed_literal_statement(arg1,arg2,arg3,(unsigned char *)arg4,arg5,arg6); r_ans = Rf_ScalarInteger(result); free(arg4); free(arg5); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_add_statement ( SEXP model, SEXP statement, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_statement *arg2 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_add_statement" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(statement, &argp2, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_add_statement" "', argument " "2"" of type '" "librdf_statement *""'"); } arg2 = (librdf_statement *)(argp2); result = (int)librdf_model_add_statement(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_add_statements ( SEXP model, SEXP statement_stream, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_stream *arg2 = (librdf_stream *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_add_statements" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(statement_stream, &argp2, SWIGTYPE_p_librdf_stream_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_add_statements" "', argument " "2"" of type '" "librdf_stream *""'"); } arg2 = (librdf_stream *)(argp2); result = (int)librdf_model_add_statements(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_remove_statement ( SEXP model, SEXP statement, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_statement *arg2 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_remove_statement" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(statement, &argp2, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_remove_statement" "', argument " "2"" of type '" "librdf_statement *""'"); } arg2 = (librdf_statement *)(argp2); result = (int)librdf_model_remove_statement(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_contains_statement ( SEXP model, SEXP statement, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_statement *arg2 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_contains_statement" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(statement, &argp2, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_contains_statement" "', argument " "2"" of type '" "librdf_statement *""'"); } arg2 = (librdf_statement *)(argp2); result = (int)librdf_model_contains_statement(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_as_stream ( SEXP model) { librdf_stream *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_as_stream" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); result = (librdf_stream *)librdf_model_as_stream(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_find_statements ( SEXP model, SEXP statement) { librdf_stream *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_statement *arg2 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_find_statements" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(statement, &argp2, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_find_statements" "', argument " "2"" of type '" "librdf_statement *""'"); } arg2 = (librdf_statement *)(argp2); result = (librdf_stream *)librdf_model_find_statements(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_find_statements_in_context ( SEXP model, SEXP statement, SEXP inNodeOrNull) { librdf_stream *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_statement *arg2 = (librdf_statement *) 0 ; librdf_node *arg3 = (librdf_node *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_find_statements_in_context" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(statement, &argp2, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_find_statements_in_context" "', argument " "2"" of type '" "librdf_statement *""'"); } arg2 = (librdf_statement *)(argp2); res3 = SWIG_R_ConvertPtr(inNodeOrNull, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_find_statements_in_context" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (librdf_stream *)librdf_model_find_statements_in_context(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_sources ( SEXP model, SEXP arc, SEXP target) { librdf_iterator *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_sources" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(arc, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_sources" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(target, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_get_sources" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (librdf_iterator *)librdf_model_get_sources(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_arcs ( SEXP model, SEXP source, SEXP target) { librdf_iterator *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_arcs" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(source, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_arcs" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(target, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_get_arcs" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (librdf_iterator *)librdf_model_get_arcs(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_targets ( SEXP model, SEXP source, SEXP arc) { librdf_iterator *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_targets" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(source, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_targets" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(arc, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_get_targets" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (librdf_iterator *)librdf_model_get_targets(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_source ( SEXP model, SEXP arc, SEXP target) { librdf_node *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_source" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(arc, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_source" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(target, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_get_source" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (librdf_node *)librdf_model_get_source(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_arc ( SEXP model, SEXP source, SEXP target) { librdf_node *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_arc" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(source, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_arc" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(target, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_get_arc" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (librdf_node *)librdf_model_get_arc(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_arcs_out ( SEXP model, SEXP node) { librdf_iterator *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_arcs_out" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(node, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_arcs_out" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); result = (librdf_iterator *)librdf_model_get_arcs_out(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_arcs_in ( SEXP model, SEXP node) { librdf_iterator *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_arcs_in" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(node, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_arcs_in" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); result = (librdf_iterator *)librdf_model_get_arcs_in(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_has_arc_in ( SEXP model, SEXP node, SEXP property, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_has_arc_in" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(node, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_has_arc_in" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(property, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_has_arc_in" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (int)librdf_model_has_arc_in(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_has_arc_out ( SEXP model, SEXP node, SEXP property, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_has_arc_out" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(node, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_has_arc_out" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(property, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_has_arc_out" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (int)librdf_model_has_arc_out(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_target ( SEXP model, SEXP source, SEXP arc) { librdf_node *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_target" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(source, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_target" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(arc, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_get_target" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (librdf_node *)librdf_model_get_target(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_context_add_statement ( SEXP model, SEXP context, SEXP statement, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_statement *arg3 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_context_add_statement" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(context, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_context_add_statement" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(statement, &argp3, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_context_add_statement" "', argument " "3"" of type '" "librdf_statement *""'"); } arg3 = (librdf_statement *)(argp3); result = (int)librdf_model_context_add_statement(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_context_add_statements ( SEXP model, SEXP context, SEXP stream, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_stream *arg3 = (librdf_stream *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_context_add_statements" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(context, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_context_add_statements" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(stream, &argp3, SWIGTYPE_p_librdf_stream_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_context_add_statements" "', argument " "3"" of type '" "librdf_stream *""'"); } arg3 = (librdf_stream *)(argp3); result = (int)librdf_model_context_add_statements(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_context_remove_statement ( SEXP model, SEXP context, SEXP statement, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; librdf_statement *arg3 = (librdf_statement *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_context_remove_statement" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(context, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_context_remove_statement" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); res3 = SWIG_R_ConvertPtr(statement, &argp3, SWIGTYPE_p_librdf_statement_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_context_remove_statement" "', argument " "3"" of type '" "librdf_statement *""'"); } arg3 = (librdf_statement *)(argp3); result = (int)librdf_model_context_remove_statement(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_context_remove_statements ( SEXP model, SEXP context, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_context_remove_statements" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(context, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_context_remove_statements" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); result = (int)librdf_model_context_remove_statements(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_context_as_stream ( SEXP model, SEXP context) { librdf_stream *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_context_as_stream" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(context, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_context_as_stream" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); result = (librdf_stream *)librdf_model_context_as_stream(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_sync ( SEXP model) { librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_sync" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); librdf_model_sync(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_contexts ( SEXP model) { librdf_iterator *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_contexts" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); result = (librdf_iterator *)librdf_model_get_contexts(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_contains_context ( SEXP model, SEXP context, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_node *arg2 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_contains_context" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(context, &argp2, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_contains_context" "', argument " "2"" of type '" "librdf_node *""'"); } arg2 = (librdf_node *)(argp2); result = (int)librdf_model_contains_context(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_get_feature ( SEXP model, SEXP feature) { librdf_node *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_get_feature" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(feature, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_get_feature" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); result = (librdf_node *)librdf_model_get_feature(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_set_feature ( SEXP model, SEXP feature, SEXP value, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_set_feature" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(feature, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_set_feature" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_R_ConvertPtr(value, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_set_feature" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (int)librdf_model_set_feature(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_load ( SEXP model, SEXP uri, SEXP name, SEXP mime_type, SEXP type_uri, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; char *arg3 = (char *) NULL ; char *arg4 = (char *) NULL ; librdf_uri *arg5 = (librdf_uri *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; int res4 ; char *buf4 = 0 ; int alloc4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_load" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_load" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_AsCharPtrAndSize(name, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_load" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); res4 = SWIG_AsCharPtrAndSize(mime_type, &buf4, NULL, &alloc4); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_model_load" "', argument " "4"" of type '" "char const *""'"); } arg4 = (char *)(buf4); res5 = SWIG_R_ConvertPtr(type_uri, &argp5, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "librdf_model_load" "', argument " "5"" of type '" "librdf_uri *""'"); } arg5 = (librdf_uri *)(argp5); result = (int)librdf_model_load(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5); r_ans = Rf_ScalarInteger(result); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_query_execute ( SEXP model, SEXP query) { librdf_query_results *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_query *arg2 = (librdf_query *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_query_execute" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(query, &argp2, SWIGTYPE_p_librdf_query, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_query_execute" "', argument " "2"" of type '" "librdf_query *""'"); } arg2 = (librdf_query *)(argp2); result = (librdf_query_results *)librdf_model_query_execute(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_query_results, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_to_string ( SEXP model, SEXP uri, SEXP name, SEXP mime_type, SEXP inUriOrNull) { char *result = 0 ; librdf_model *arg1 = (librdf_model *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; char *arg3 = (char *) NULL ; char *arg4 = (char *) NULL ; librdf_uri *arg5 = (librdf_uri *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; int res4 ; char *buf4 = 0 ; int alloc4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_to_string" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); res2 = SWIG_R_ConvertPtr(uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_model_to_string" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_AsCharPtrAndSize(name, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_model_to_string" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); res4 = SWIG_AsCharPtrAndSize(mime_type, &buf4, NULL, &alloc4); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_model_to_string" "', argument " "4"" of type '" "char const *""'"); } arg4 = (char *)(buf4); res5 = SWIG_R_ConvertPtr(inUriOrNull, &argp5, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "librdf_model_to_string" "', argument " "5"" of type '" "librdf_uri *""'"); } arg5 = (librdf_uri *)(argp5); result = (char *)librdf_model_to_string(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); free((char*)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_transaction_start ( SEXP model, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_transaction_start" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); result = (int)librdf_model_transaction_start(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_transaction_commit ( SEXP model, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_transaction_commit" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); result = (int)librdf_model_transaction_commit(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_model_transaction_rollback ( SEXP model, SEXP s_swig_copy) { int result; librdf_model *arg1 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(model, &argp1, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_model_transaction_rollback" "', argument " "1"" of type '" "librdf_model *""'"); } arg1 = (librdf_model *)(argp1); result = (int)librdf_model_transaction_rollback(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_storage ( SEXP world, SEXP storage_name, SEXP name, SEXP options_string) { librdf_storage *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; char *arg4 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_storage" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); arg2 = (char *)(SWIG_strdup(CHAR(STRING_ELT(storage_name, 0)))); arg3 = (char *)(SWIG_strdup(CHAR(STRING_ELT(name, 0)))); arg4 = (char *)(SWIG_strdup(CHAR(STRING_ELT(options_string, 0)))); result = (librdf_storage *)librdf_new_storage(arg1,arg2,arg3,arg4); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_storage_s, R_SWIG_OWNER | 0 ); free(arg2); free(arg3); free(arg4); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_storage_from_storage ( SEXP old_storage) { librdf_storage *result = 0 ; librdf_storage *arg1 = (librdf_storage *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(old_storage, &argp1, SWIGTYPE_p_librdf_storage_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_storage_from_storage" "', argument " "1"" of type '" "librdf_storage *""'"); } arg1 = (librdf_storage *)(argp1); result = (librdf_storage *)librdf_new_storage_from_storage(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_storage_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_storage ( SEXP storage) { librdf_storage *arg1 = (librdf_storage *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(storage, &argp1, SWIGTYPE_p_librdf_storage_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_storage" "', argument " "1"" of type '" "librdf_storage *""'"); } arg1 = (librdf_storage *)(argp1); librdf_free_storage(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_check_name ( SEXP world, SEXP name, SEXP s_swig_copy) { int result; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_check_name" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_check_name" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); result = (int)librdf_parser_check_name(arg1,(char const *)arg2); r_ans = Rf_ScalarInteger(result); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_parser ( SEXP world, SEXP name, SEXP mime_type, SEXP type_uri) { librdf_parser *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; librdf_uri *arg4 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_parser" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_parser" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_AsCharPtrAndSize(mime_type, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_parser" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); res4 = SWIG_R_ConvertPtr(type_uri, &argp4, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_new_parser" "', argument " "4"" of type '" "librdf_uri *""'"); } arg4 = (librdf_uri *)(argp4); result = (librdf_parser *)librdf_new_parser(arg1,(char const *)arg2,(char const *)arg3,arg4); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_parser_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_parser ( SEXP parser) { librdf_parser *arg1 = (librdf_parser *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_parser" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); librdf_free_parser(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_parse_as_stream ( SEXP parser, SEXP uri, SEXP inUriorNull) { librdf_stream *result = 0 ; librdf_parser *arg1 = (librdf_parser *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; librdf_uri *arg3 = (librdf_uri *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_parse_as_stream" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); res2 = SWIG_R_ConvertPtr(uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_parse_as_stream" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_R_ConvertPtr(inUriorNull, &argp3, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_parser_parse_as_stream" "', argument " "3"" of type '" "librdf_uri *""'"); } arg3 = (librdf_uri *)(argp3); result = (librdf_stream *)librdf_parser_parse_as_stream(arg1,arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_parse_into_model ( SEXP parser, SEXP uri, SEXP inUriOrNull, SEXP model, SEXP s_swig_copy) { int result; librdf_parser *arg1 = (librdf_parser *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; librdf_uri *arg3 = (librdf_uri *) 0 ; librdf_model *arg4 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_parse_into_model" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); res2 = SWIG_R_ConvertPtr(uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_parse_into_model" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_R_ConvertPtr(inUriOrNull, &argp3, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_parser_parse_into_model" "', argument " "3"" of type '" "librdf_uri *""'"); } arg3 = (librdf_uri *)(argp3); res4 = SWIG_R_ConvertPtr(model, &argp4, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_parser_parse_into_model" "', argument " "4"" of type '" "librdf_model *""'"); } arg4 = (librdf_model *)(argp4); result = (int)librdf_parser_parse_into_model(arg1,arg2,arg3,arg4); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_parse_string_as_stream ( SEXP parser, SEXP string, SEXP base_uri) { librdf_stream *result = 0 ; librdf_parser *arg1 = (librdf_parser *) 0 ; char *arg2 = (char *) 0 ; librdf_uri *arg3 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_parse_string_as_stream" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); res2 = SWIG_AsCharPtrAndSize(string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_parse_string_as_stream" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_R_ConvertPtr(base_uri, &argp3, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_parser_parse_string_as_stream" "', argument " "3"" of type '" "librdf_uri *""'"); } arg3 = (librdf_uri *)(argp3); result = (librdf_stream *)librdf_parser_parse_string_as_stream(arg1,(unsigned char const *)arg2,arg3); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_parse_string_into_model ( SEXP parser, SEXP string, SEXP base_uri, SEXP model, SEXP s_swig_copy) { int result; librdf_parser *arg1 = (librdf_parser *) 0 ; char *arg2 = (char *) 0 ; librdf_uri *arg3 = (librdf_uri *) 0 ; librdf_model *arg4 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_parse_string_into_model" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); res2 = SWIG_AsCharPtrAndSize(string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_parse_string_into_model" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_R_ConvertPtr(base_uri, &argp3, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_parser_parse_string_into_model" "', argument " "3"" of type '" "librdf_uri *""'"); } arg3 = (librdf_uri *)(argp3); res4 = SWIG_R_ConvertPtr(model, &argp4, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_parser_parse_string_into_model" "', argument " "4"" of type '" "librdf_model *""'"); } arg4 = (librdf_model *)(argp4); result = (int)librdf_parser_parse_string_into_model(arg1,(unsigned char const *)arg2,arg3,arg4); r_ans = Rf_ScalarInteger(result); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_parse_counted_string_as_stream ( SEXP parser, SEXP string, SEXP length, SEXP base_uri) { librdf_stream *result = 0 ; librdf_parser *arg1 = (librdf_parser *) 0 ; char *arg2 = (char *) 0 ; size_t arg3 ; librdf_uri *arg4 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_parse_counted_string_as_stream" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); res2 = SWIG_AsCharPtrAndSize(string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_parse_counted_string_as_stream" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); ecode3 = SWIG_AsVal_int(length, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "librdf_parser_parse_counted_string_as_stream" "', argument " "3"" of type '" "size_t""'"); } arg3 = (size_t)(val3); res4 = SWIG_R_ConvertPtr(base_uri, &argp4, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_parser_parse_counted_string_as_stream" "', argument " "4"" of type '" "librdf_uri *""'"); } arg4 = (librdf_uri *)(argp4); result = (librdf_stream *)librdf_parser_parse_counted_string_as_stream(arg1,(unsigned char const *)arg2,arg3,arg4); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, R_SWIG_EXTERNAL | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_parse_counted_string_into_model ( SEXP parser, SEXP string, SEXP length, SEXP base_uri, SEXP model, SEXP s_swig_copy) { int result; librdf_parser *arg1 = (librdf_parser *) 0 ; char *arg2 = (char *) 0 ; size_t arg3 ; librdf_uri *arg4 = (librdf_uri *) 0 ; librdf_model *arg5 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_parse_counted_string_into_model" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); res2 = SWIG_AsCharPtrAndSize(string, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_parse_counted_string_into_model" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); ecode3 = SWIG_AsVal_int(length, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "librdf_parser_parse_counted_string_into_model" "', argument " "3"" of type '" "size_t""'"); } arg3 = (size_t)(val3); res4 = SWIG_R_ConvertPtr(base_uri, &argp4, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_parser_parse_counted_string_into_model" "', argument " "4"" of type '" "librdf_uri *""'"); } arg4 = (librdf_uri *)(argp4); res5 = SWIG_R_ConvertPtr(model, &argp5, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "librdf_parser_parse_counted_string_into_model" "', argument " "5"" of type '" "librdf_model *""'"); } arg5 = (librdf_model *)(argp5); result = (int)librdf_parser_parse_counted_string_into_model(arg1,(unsigned char const *)arg2,arg3,arg4,arg5); r_ans = Rf_ScalarInteger(result); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_get_feature ( SEXP parser, SEXP feature) { librdf_node *result = 0 ; librdf_parser *arg1 = (librdf_parser *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_get_feature" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); res2 = SWIG_R_ConvertPtr(feature, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_get_feature" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); result = (librdf_node *)librdf_parser_get_feature(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_set_feature ( SEXP parser, SEXP feature, SEXP value, SEXP s_swig_copy) { int result; librdf_parser *arg1 = (librdf_parser *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_set_feature" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); res2 = SWIG_R_ConvertPtr(feature, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_set_feature" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_R_ConvertPtr(value, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_parser_set_feature" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (int)librdf_parser_set_feature(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_guess_name2 ( SEXP world, SEXP mime_type, SEXP buffer, SEXP identifier) { char *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; char *arg4 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; int res4 ; char *buf4 = 0 ; int alloc4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_guess_name2" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(mime_type, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_parser_guess_name2" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_AsCharPtrAndSize(buffer, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_parser_guess_name2" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); res4 = SWIG_AsCharPtrAndSize(identifier, &buf4, NULL, &alloc4); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_parser_guess_name2" "', argument " "4"" of type '" "char const *""'"); } arg4 = (char *)(buf4); result = (char *)librdf_parser_guess_name2(arg1,(char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4); r_ans = SWIG_FromCharPtr((const char *)result); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_get_namespaces_seen_prefix ( SEXP parser, SEXP offset) { char *result = 0 ; librdf_parser *arg1 = (librdf_parser *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_get_namespaces_seen_prefix" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); arg2 = (int)(INTEGER(offset)[0]); result = (char *)librdf_parser_get_namespaces_seen_prefix(arg1,arg2); r_ans = SWIG_FromCharPtr((const char *)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_get_namespaces_seen_uri ( SEXP parser, SEXP offset) { librdf_uri *result = 0 ; librdf_parser *arg1 = (librdf_parser *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_get_namespaces_seen_uri" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); arg2 = (int)(INTEGER(offset)[0]); result = (librdf_uri *)librdf_parser_get_namespaces_seen_uri(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_parser_get_namespaces_seen_count ( SEXP parser, SEXP s_swig_copy) { int result; librdf_parser *arg1 = (librdf_parser *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(parser, &argp1, SWIGTYPE_p_librdf_parser_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_parser_get_namespaces_seen_count" "', argument " "1"" of type '" "librdf_parser *""'"); } arg1 = (librdf_parser *)(argp1); result = (int)librdf_parser_get_namespaces_seen_count(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_query ( SEXP world, SEXP name, SEXP uri, SEXP query_string, SEXP base_uri) { librdf_query *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; librdf_uri *arg3 = (librdf_uri *) 0 ; char *arg4 = (char *) 0 ; librdf_uri *arg5 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; int res4 ; char *buf4 = 0 ; int alloc4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_query" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_query" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_R_ConvertPtr(uri, &argp3, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_query" "', argument " "3"" of type '" "librdf_uri *""'"); } arg3 = (librdf_uri *)(argp3); res4 = SWIG_AsCharPtrAndSize(query_string, &buf4, NULL, &alloc4); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_new_query" "', argument " "4"" of type '" "char const *""'"); } arg4 = (char *)(buf4); res5 = SWIG_R_ConvertPtr(base_uri, &argp5, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "librdf_new_query" "', argument " "5"" of type '" "librdf_uri *""'"); } arg5 = (librdf_uri *)(argp5); result = (librdf_query *)librdf_new_query(arg1,(char const *)arg2,arg3,(unsigned char const *)arg4,arg5); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_query, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_query_from_query ( SEXP old_query) { librdf_query *result = 0 ; librdf_query *arg1 = (librdf_query *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(old_query, &argp1, SWIGTYPE_p_librdf_query, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_query_from_query" "', argument " "1"" of type '" "librdf_query *""'"); } arg1 = (librdf_query *)(argp1); result = (librdf_query *)librdf_new_query_from_query(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_query, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_query ( SEXP query) { librdf_query *arg1 = (librdf_query *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query, &argp1, SWIGTYPE_p_librdf_query, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_query" "', argument " "1"" of type '" "librdf_query *""'"); } arg1 = (librdf_query *)(argp1); librdf_free_query(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_execute ( SEXP query, SEXP model) { librdf_query_results *result = 0 ; librdf_query *arg1 = (librdf_query *) 0 ; librdf_model *arg2 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query, &argp1, SWIGTYPE_p_librdf_query, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_execute" "', argument " "1"" of type '" "librdf_query *""'"); } arg1 = (librdf_query *)(argp1); res2 = SWIG_R_ConvertPtr(model, &argp2, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_query_execute" "', argument " "2"" of type '" "librdf_model *""'"); } arg2 = (librdf_model *)(argp2); result = (librdf_query_results *)librdf_query_execute(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_query_results, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_get_limit ( SEXP query, SEXP s_swig_copy) { int result; librdf_query *arg1 = (librdf_query *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query, &argp1, SWIGTYPE_p_librdf_query, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_get_limit" "', argument " "1"" of type '" "librdf_query *""'"); } arg1 = (librdf_query *)(argp1); result = (int)librdf_query_get_limit(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_set_limit ( SEXP query, SEXP limit, SEXP s_swig_copy) { int result; librdf_query *arg1 = (librdf_query *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query, &argp1, SWIGTYPE_p_librdf_query, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_set_limit" "', argument " "1"" of type '" "librdf_query *""'"); } arg1 = (librdf_query *)(argp1); arg2 = (int)(INTEGER(limit)[0]); result = (int)librdf_query_set_limit(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_get_offset ( SEXP query, SEXP s_swig_copy) { int result; librdf_query *arg1 = (librdf_query *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query, &argp1, SWIGTYPE_p_librdf_query, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_get_offset" "', argument " "1"" of type '" "librdf_query *""'"); } arg1 = (librdf_query *)(argp1); result = (int)librdf_query_get_offset(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_set_offset ( SEXP query, SEXP offset, SEXP s_swig_copy) { int result; librdf_query *arg1 = (librdf_query *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query, &argp1, SWIGTYPE_p_librdf_query, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_set_offset" "', argument " "1"" of type '" "librdf_query *""'"); } arg1 = (librdf_query *)(argp1); arg2 = (int)(INTEGER(offset)[0]); result = (int)librdf_query_set_offset(arg1,arg2); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_as_stream ( SEXP query_results) { librdf_stream *result = 0 ; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_as_stream" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (librdf_stream *)librdf_query_results_as_stream(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_get_count ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_get_count" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_get_count(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_next ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_next" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_next(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_finished ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_finished" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_finished(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_get_binding_value ( SEXP query_results, SEXP offset) { librdf_node *result = 0 ; librdf_query_results *arg1 = (librdf_query_results *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_get_binding_value" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); arg2 = (int)(INTEGER(offset)[0]); result = (librdf_node *)librdf_query_results_get_binding_value(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_get_binding_name ( SEXP query_results, SEXP offset) { char *result = 0 ; librdf_query_results *arg1 = (librdf_query_results *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_get_binding_name" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); arg2 = (int)(INTEGER(offset)[0]); result = (char *)librdf_query_results_get_binding_name(arg1,arg2); r_ans = SWIG_FromCharPtr((const char *)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_get_binding_value_by_name ( SEXP query_results, SEXP name) { librdf_node *result = 0 ; librdf_query_results *arg1 = (librdf_query_results *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_get_binding_value_by_name" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_query_results_get_binding_value_by_name" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); result = (librdf_node *)librdf_query_results_get_binding_value_by_name(arg1,(char const *)arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_get_bindings_count ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_get_bindings_count" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_get_bindings_count(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_to_file2 ( SEXP query_results, SEXP name, SEXP mime_type, SEXP format_uri, SEXP base_uri, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; librdf_uri *arg4 = (librdf_uri *) 0 ; librdf_uri *arg5 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_to_file2" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_query_results_to_file2" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_AsCharPtrAndSize(mime_type, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_query_results_to_file2" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); res4 = SWIG_R_ConvertPtr(format_uri, &argp4, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_query_results_to_file2" "', argument " "4"" of type '" "librdf_uri *""'"); } arg4 = (librdf_uri *)(argp4); res5 = SWIG_R_ConvertPtr(base_uri, &argp5, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "librdf_query_results_to_file2" "', argument " "5"" of type '" "librdf_uri *""'"); } arg5 = (librdf_uri *)(argp5); result = (int)librdf_query_results_to_file2(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); r_ans = Rf_ScalarInteger(result); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_to_string2 ( SEXP query_results, SEXP name, SEXP mime_type, SEXP format_uri, SEXP base_uri) { char *result = 0 ; librdf_query_results *arg1 = (librdf_query_results *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; librdf_uri *arg4 = (librdf_uri *) 0 ; librdf_uri *arg5 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_to_string2" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_query_results_to_string2" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_AsCharPtrAndSize(mime_type, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_query_results_to_string2" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); res4 = SWIG_R_ConvertPtr(format_uri, &argp4, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_query_results_to_string2" "', argument " "4"" of type '" "librdf_uri *""'"); } arg4 = (librdf_uri *)(argp4); res5 = SWIG_R_ConvertPtr(base_uri, &argp5, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "librdf_query_results_to_string2" "', argument " "5"" of type '" "librdf_uri *""'"); } arg5 = (librdf_uri *)(argp5); result = (char *)librdf_query_results_to_string2(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); free((char*)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_query_results ( SEXP query_results) { librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_query_results" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); librdf_free_query_results(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_is_bindings ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_is_bindings" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_is_bindings(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_is_boolean ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_is_boolean" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_is_boolean(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_is_graph ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_is_graph" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_is_graph(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_is_syntax ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_is_syntax" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_is_syntax(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_query_results_get_boolean ( SEXP query_results, SEXP s_swig_copy) { int result; librdf_query_results *arg1 = (librdf_query_results *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(query_results, &argp1, SWIGTYPE_p_librdf_query_results, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_query_results_get_boolean" "', argument " "1"" of type '" "librdf_query_results *""'"); } arg1 = (librdf_query_results *)(argp1); result = (int)librdf_query_results_get_boolean(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_serializer_check_name ( SEXP world, SEXP name, SEXP s_swig_copy) { int result; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_serializer_check_name" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_serializer_check_name" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); result = (int)librdf_serializer_check_name(arg1,(char const *)arg2); r_ans = Rf_ScalarInteger(result); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_new_serializer ( SEXP world, SEXP name, SEXP mime_type, SEXP type_uri) { librdf_serializer *result = 0 ; librdf_world *arg1 = (librdf_world *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; librdf_uri *arg4 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_new_serializer" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_new_serializer" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_AsCharPtrAndSize(mime_type, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_new_serializer" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); res4 = SWIG_R_ConvertPtr(type_uri, &argp4, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_new_serializer" "', argument " "4"" of type '" "librdf_uri *""'"); } arg4 = (librdf_uri *)(argp4); result = (librdf_serializer *)librdf_new_serializer(arg1,(char const *)arg2,(char const *)arg3,arg4); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_serializer_s, R_SWIG_OWNER | 0 ); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_serializer ( SEXP serializer) { librdf_serializer *arg1 = (librdf_serializer *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(serializer, &argp1, SWIGTYPE_p_librdf_serializer_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_serializer" "', argument " "1"" of type '" "librdf_serializer *""'"); } arg1 = (librdf_serializer *)(argp1); librdf_free_serializer(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_serializer_serialize_stream_to_file ( SEXP serializer, SEXP name, SEXP base_uri, SEXP stream, SEXP s_swig_copy) { int result; librdf_serializer *arg1 = (librdf_serializer *) 0 ; char *arg2 = (char *) 0 ; librdf_uri *arg3 = (librdf_uri *) 0 ; librdf_stream *arg4 = (librdf_stream *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(serializer, &argp1, SWIGTYPE_p_librdf_serializer_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_serializer_serialize_stream_to_file" "', argument " "1"" of type '" "librdf_serializer *""'"); } arg1 = (librdf_serializer *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_serializer_serialize_stream_to_file" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_R_ConvertPtr(base_uri, &argp3, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_serializer_serialize_stream_to_file" "', argument " "3"" of type '" "librdf_uri *""'"); } arg3 = (librdf_uri *)(argp3); res4 = SWIG_R_ConvertPtr(stream, &argp4, SWIGTYPE_p_librdf_stream_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_serializer_serialize_stream_to_file" "', argument " "4"" of type '" "librdf_stream *""'"); } arg4 = (librdf_stream *)(argp4); result = (int)librdf_serializer_serialize_stream_to_file(arg1,(char const *)arg2,arg3,arg4); r_ans = Rf_ScalarInteger(result); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_serializer_serialize_model_to_file ( SEXP serializer, SEXP name, SEXP inUriOrNull, SEXP model, SEXP s_swig_copy) { int result; librdf_serializer *arg1 = (librdf_serializer *) 0 ; char *arg2 = (char *) 0 ; librdf_uri *arg3 = (librdf_uri *) 0 ; librdf_model *arg4 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(serializer, &argp1, SWIGTYPE_p_librdf_serializer_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_serializer_serialize_model_to_file" "', argument " "1"" of type '" "librdf_serializer *""'"); } arg1 = (librdf_serializer *)(argp1); res2 = SWIG_AsCharPtrAndSize(name, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_serializer_serialize_model_to_file" "', argument " "2"" of type '" "char const *""'"); } arg2 = (char *)(buf2); res3 = SWIG_R_ConvertPtr(inUriOrNull, &argp3, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_serializer_serialize_model_to_file" "', argument " "3"" of type '" "librdf_uri *""'"); } arg3 = (librdf_uri *)(argp3); res4 = SWIG_R_ConvertPtr(model, &argp4, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "librdf_serializer_serialize_model_to_file" "', argument " "4"" of type '" "librdf_model *""'"); } arg4 = (librdf_model *)(argp4); result = (int)librdf_serializer_serialize_model_to_file(arg1,(char const *)arg2,arg3,arg4); r_ans = Rf_ScalarInteger(result); if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_serializer_serialize_stream_to_string ( SEXP serializer, SEXP base_uri, SEXP stream) { char *result = 0 ; librdf_serializer *arg1 = (librdf_serializer *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; librdf_stream *arg3 = (librdf_stream *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(serializer, &argp1, SWIGTYPE_p_librdf_serializer_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_serializer_serialize_stream_to_string" "', argument " "1"" of type '" "librdf_serializer *""'"); } arg1 = (librdf_serializer *)(argp1); res2 = SWIG_R_ConvertPtr(base_uri, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_serializer_serialize_stream_to_string" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_R_ConvertPtr(stream, &argp3, SWIGTYPE_p_librdf_stream_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_serializer_serialize_stream_to_string" "', argument " "3"" of type '" "librdf_stream *""'"); } arg3 = (librdf_stream *)(argp3); result = (char *)librdf_serializer_serialize_stream_to_string(arg1,arg2,arg3); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; free((char*)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_serializer_serialize_model_to_string ( SEXP serializer, SEXP inUriOrNull, SEXP model) { char *result = 0 ; librdf_serializer *arg1 = (librdf_serializer *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; librdf_model *arg3 = (librdf_model *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(serializer, &argp1, SWIGTYPE_p_librdf_serializer_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_serializer_serialize_model_to_string" "', argument " "1"" of type '" "librdf_serializer *""'"); } arg1 = (librdf_serializer *)(argp1); res2 = SWIG_R_ConvertPtr(inUriOrNull, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_serializer_serialize_model_to_string" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_R_ConvertPtr(model, &argp3, SWIGTYPE_p_librdf_model_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_serializer_serialize_model_to_string" "', argument " "3"" of type '" "librdf_model *""'"); } arg3 = (librdf_model *)(argp3); result = (char *)librdf_serializer_serialize_model_to_string(arg1,arg2,arg3); r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; free((char*)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_serializer_get_feature ( SEXP serializer, SEXP feature) { librdf_node *result = 0 ; librdf_serializer *arg1 = (librdf_serializer *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(serializer, &argp1, SWIGTYPE_p_librdf_serializer_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_serializer_get_feature" "', argument " "1"" of type '" "librdf_serializer *""'"); } arg1 = (librdf_serializer *)(argp1); res2 = SWIG_R_ConvertPtr(feature, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_serializer_get_feature" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); result = (librdf_node *)librdf_serializer_get_feature(arg1,arg2); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_serializer_set_feature ( SEXP serializer, SEXP feature, SEXP value, SEXP s_swig_copy) { int result; librdf_serializer *arg1 = (librdf_serializer *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; librdf_node *arg3 = (librdf_node *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(serializer, &argp1, SWIGTYPE_p_librdf_serializer_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_serializer_set_feature" "', argument " "1"" of type '" "librdf_serializer *""'"); } arg1 = (librdf_serializer *)(argp1); res2 = SWIG_R_ConvertPtr(feature, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_serializer_set_feature" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_R_ConvertPtr(value, &argp3, SWIGTYPE_p_librdf_node_s, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_serializer_set_feature" "', argument " "3"" of type '" "librdf_node *""'"); } arg3 = (librdf_node *)(argp3); result = (int)librdf_serializer_set_feature(arg1,arg2,arg3); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_serializer_set_namespace ( SEXP serializer, SEXP nspace, SEXP prefix, SEXP s_swig_copy) { int result; librdf_serializer *arg1 = (librdf_serializer *) 0 ; librdf_uri *arg2 = (librdf_uri *) 0 ; char *arg3 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(serializer, &argp1, SWIGTYPE_p_librdf_serializer_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_serializer_set_namespace" "', argument " "1"" of type '" "librdf_serializer *""'"); } arg1 = (librdf_serializer *)(argp1); res2 = SWIG_R_ConvertPtr(nspace, &argp2, SWIGTYPE_p_librdf_uri_s, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "librdf_serializer_set_namespace" "', argument " "2"" of type '" "librdf_uri *""'"); } arg2 = (librdf_uri *)(argp2); res3 = SWIG_AsCharPtrAndSize(prefix, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "librdf_serializer_set_namespace" "', argument " "3"" of type '" "char const *""'"); } arg3 = (char *)(buf3); result = (int)librdf_serializer_set_namespace(arg1,arg2,(char const *)arg3); r_ans = Rf_ScalarInteger(result); if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_free_stream ( SEXP stream) { librdf_stream *arg1 = (librdf_stream *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(stream, &argp1, SWIGTYPE_p_librdf_stream_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_free_stream" "', argument " "1"" of type '" "librdf_stream *""'"); } arg1 = (librdf_stream *)(argp1); librdf_free_stream(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_stream_end ( SEXP stream, SEXP s_swig_copy) { int result; librdf_stream *arg1 = (librdf_stream *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(stream, &argp1, SWIGTYPE_p_librdf_stream_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_stream_end" "', argument " "1"" of type '" "librdf_stream *""'"); } arg1 = (librdf_stream *)(argp1); result = (int)librdf_stream_end(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_stream_next ( SEXP stream, SEXP s_swig_copy) { int result; librdf_stream *arg1 = (librdf_stream *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(stream, &argp1, SWIGTYPE_p_librdf_stream_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_stream_next" "', argument " "1"" of type '" "librdf_stream *""'"); } arg1 = (librdf_stream *)(argp1); result = (int)librdf_stream_next(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_stream_get_object ( SEXP stream) { librdf_statement *result = 0 ; librdf_stream *arg1 = (librdf_stream *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(stream, &argp1, SWIGTYPE_p_librdf_stream_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_stream_get_object" "', argument " "1"" of type '" "librdf_stream *""'"); } arg1 = (librdf_stream *)(argp1); result = (librdf_statement *)librdf_stream_get_object(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_statement_s, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_log_message_code ( SEXP message, SEXP s_swig_copy) { int result; librdf_log_message *arg1 = (librdf_log_message *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(message, &argp1, SWIGTYPE_p_librdf_log_message, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_log_message_code" "', argument " "1"" of type '" "librdf_log_message *""'"); } arg1 = (librdf_log_message *)(argp1); result = (int)librdf_log_message_code(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_log_message_level ( SEXP message, SEXP s_swig_copy) { int result; librdf_log_message *arg1 = (librdf_log_message *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(message, &argp1, SWIGTYPE_p_librdf_log_message, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_log_message_level" "', argument " "1"" of type '" "librdf_log_message *""'"); } arg1 = (librdf_log_message *)(argp1); result = (int)librdf_log_message_level(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_log_message_facility ( SEXP message, SEXP s_swig_copy) { int result; librdf_log_message *arg1 = (librdf_log_message *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(message, &argp1, SWIGTYPE_p_librdf_log_message, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_log_message_facility" "', argument " "1"" of type '" "librdf_log_message *""'"); } arg1 = (librdf_log_message *)(argp1); result = (int)librdf_log_message_facility(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_log_message_message ( SEXP message) { char *result = 0 ; librdf_log_message *arg1 = (librdf_log_message *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(message, &argp1, SWIGTYPE_p_librdf_log_message, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_log_message_message" "', argument " "1"" of type '" "librdf_log_message *""'"); } arg1 = (librdf_log_message *)(argp1); result = (char *)librdf_log_message_message(arg1); r_ans = SWIG_FromCharPtr((const char *)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_log_message_locator ( SEXP message) { raptor_locator *result = 0 ; librdf_log_message *arg1 = (librdf_log_message *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(message, &argp1, SWIGTYPE_p_librdf_log_message, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_log_message_locator" "', argument " "1"" of type '" "librdf_log_message *""'"); } arg1 = (librdf_log_message *)(argp1); result = (raptor_locator *)librdf_log_message_locator(arg1); r_ans = SWIG_R_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_raptor_locator, R_SWIG_EXTERNAL | 0 ); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_locator_line ( SEXP locator, SEXP s_swig_copy) { int result; raptor_locator *arg1 = (raptor_locator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(locator, &argp1, SWIGTYPE_p_raptor_locator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "raptor_locator_line" "', argument " "1"" of type '" "raptor_locator *""'"); } arg1 = (raptor_locator *)(argp1); result = (int)raptor_locator_line(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_locator_column ( SEXP locator, SEXP s_swig_copy) { int result; raptor_locator *arg1 = (raptor_locator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(locator, &argp1, SWIGTYPE_p_raptor_locator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "raptor_locator_column" "', argument " "1"" of type '" "raptor_locator *""'"); } arg1 = (raptor_locator *)(argp1); result = (int)raptor_locator_column(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_locator_byte ( SEXP locator, SEXP s_swig_copy) { int result; raptor_locator *arg1 = (raptor_locator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(locator, &argp1, SWIGTYPE_p_raptor_locator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "raptor_locator_byte" "', argument " "1"" of type '" "raptor_locator *""'"); } arg1 = (raptor_locator *)(argp1); result = (int)raptor_locator_byte(arg1); r_ans = Rf_ScalarInteger(result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_locator_file ( SEXP locator) { char *result = 0 ; raptor_locator *arg1 = (raptor_locator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(locator, &argp1, SWIGTYPE_p_raptor_locator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "raptor_locator_file" "', argument " "1"" of type '" "raptor_locator *""'"); } arg1 = (raptor_locator *)(argp1); result = (char *)raptor_locator_file(arg1); r_ans = SWIG_FromCharPtr((const char *)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_locator_uri ( SEXP locator) { char *result = 0 ; raptor_locator *arg1 = (raptor_locator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(locator, &argp1, SWIGTYPE_p_raptor_locator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "raptor_locator_uri" "', argument " "1"" of type '" "raptor_locator *""'"); } arg1 = (raptor_locator *)(argp1); result = (char *)raptor_locator_uri(arg1); r_ans = SWIG_FromCharPtr((const char *)result); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_internal_test_error ( SEXP world) { librdf_world *arg1 = (librdf_world *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_internal_test_error" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); librdf_internal_test_error(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_internal_test_warning ( SEXP world) { librdf_world *arg1 = (librdf_world *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; res1 = SWIG_R_ConvertPtr(world, &argp1, SWIGTYPE_p_librdf_world_s, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "librdf_internal_test_warning" "', argument " "1"" of type '" "librdf_world *""'"); } arg1 = (librdf_world *)(argp1); librdf_internal_test_warning(arg1); r_ans = R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_short_copyright_string_get ( SEXP s_swig_copy) { char *result = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (char *)(char *)librdf_short_copyright_string; r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_copyright_string_get ( SEXP s_swig_copy) { char *result = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (char *)(char *)librdf_copyright_string; r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_version_string_get ( SEXP s_swig_copy) { char *result = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (char *)(char *)librdf_version_string; r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_version_major_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)librdf_version_major; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_version_minor_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)librdf_version_minor; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_version_release_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)librdf_version_release; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_librdf_version_decimal_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)librdf_version_decimal; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_version_string_get ( SEXP s_swig_copy) { char *result = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (char *)(char *)raptor_version_string; r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_version_major_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)raptor_version_major; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_version_minor_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)raptor_version_minor; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_version_release_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)raptor_version_release; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_raptor_version_decimal_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)raptor_version_decimal; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_rasqal_version_string_get ( SEXP s_swig_copy) { char *result = 0 ; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (char *)(char *)rasqal_version_string; r_ans = result ? Rf_mkString((char *)(result)) : R_NilValue; vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_rasqal_version_major_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)rasqal_version_major; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_rasqal_version_minor_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)rasqal_version_minor; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_rasqal_version_release_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)rasqal_version_release; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } SWIGEXPORT SEXP R_swig_rasqal_version_decimal_get ( SEXP s_swig_copy) { unsigned int result; unsigned int r_nprotect = 0; SEXP r_ans = R_NilValue ; VMAXTYPE r_vmax = vmaxget() ; result = (unsigned int)(unsigned int)rasqal_version_decimal; r_ans = SWIG_From_unsigned_SS_int((unsigned int)(result)); vmaxset(r_vmax); if(r_nprotect) Rf_unprotect(r_nprotect); return r_ans; } #ifdef __cplusplus } #endif /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_digest_s = {"_p_librdf_digest_s", "struct librdf_digest_s *|librdf_digest *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_hash_s = {"_p_librdf_hash_s", "librdf_hash *|struct librdf_hash_s *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_iterator_s = {"_p_librdf_iterator_s", "struct librdf_iterator_s *|librdf_iterator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_log_func = {"_p_librdf_log_func", "librdf_log_func *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_log_message = {"_p_librdf_log_message", "librdf_log_message *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_model_s = {"_p_librdf_model_s", "struct librdf_model_s *|librdf_model *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_node_s = {"_p_librdf_node_s", "struct librdf_node_s *|librdf_node *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_parser_s = {"_p_librdf_parser_s", "librdf_parser *|struct librdf_parser_s *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_query = {"_p_librdf_query", "librdf_query *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_query_results = {"_p_librdf_query_results", "librdf_query_results *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_serializer_s = {"_p_librdf_serializer_s", "struct librdf_serializer_s *|librdf_serializer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_statement_s = {"_p_librdf_statement_s", "struct librdf_statement_s *|librdf_statement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_storage_s = {"_p_librdf_storage_s", "struct librdf_storage_s *|librdf_storage *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_stream_s = {"_p_librdf_stream_s", "struct librdf_stream_s *|librdf_stream *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_uri_s = {"_p_librdf_uri_s", "librdf_uri *|struct librdf_uri_s *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_librdf_world_s = {"_p_librdf_world_s", "struct librdf_world_s *|librdf_world *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_raptor_locator = {"_p_raptor_locator", "raptor_locator *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_char, &_swigt__p_librdf_digest_s, &_swigt__p_librdf_hash_s, &_swigt__p_librdf_iterator_s, &_swigt__p_librdf_log_func, &_swigt__p_librdf_log_message, &_swigt__p_librdf_model_s, &_swigt__p_librdf_node_s, &_swigt__p_librdf_parser_s, &_swigt__p_librdf_query, &_swigt__p_librdf_query_results, &_swigt__p_librdf_serializer_s, &_swigt__p_librdf_statement_s, &_swigt__p_librdf_storage_s, &_swigt__p_librdf_stream_s, &_swigt__p_librdf_uri_s, &_swigt__p_librdf_world_s, &_swigt__p_p_char, &_swigt__p_raptor_locator, }; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_digest_s[] = { {&_swigt__p_librdf_digest_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_hash_s[] = { {&_swigt__p_librdf_hash_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_iterator_s[] = { {&_swigt__p_librdf_iterator_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_log_func[] = { {&_swigt__p_librdf_log_func, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_log_message[] = { {&_swigt__p_librdf_log_message, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_model_s[] = { {&_swigt__p_librdf_model_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_node_s[] = { {&_swigt__p_librdf_node_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_parser_s[] = { {&_swigt__p_librdf_parser_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_query[] = { {&_swigt__p_librdf_query, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_query_results[] = { {&_swigt__p_librdf_query_results, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_serializer_s[] = { {&_swigt__p_librdf_serializer_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_statement_s[] = { {&_swigt__p_librdf_statement_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_storage_s[] = { {&_swigt__p_librdf_storage_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_stream_s[] = { {&_swigt__p_librdf_stream_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_uri_s[] = { {&_swigt__p_librdf_uri_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_librdf_world_s[] = { {&_swigt__p_librdf_world_s, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_raptor_locator[] = { {&_swigt__p_raptor_locator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_char, _swigc__p_librdf_digest_s, _swigc__p_librdf_hash_s, _swigc__p_librdf_iterator_s, _swigc__p_librdf_log_func, _swigc__p_librdf_log_message, _swigc__p_librdf_model_s, _swigc__p_librdf_node_s, _swigc__p_librdf_parser_s, _swigc__p_librdf_query, _swigc__p_librdf_query_results, _swigc__p_librdf_serializer_s, _swigc__p_librdf_statement_s, _swigc__p_librdf_storage_s, _swigc__p_librdf_stream_s, _swigc__p_librdf_uri_s, _swigc__p_librdf_world_s, _swigc__p_p_char, _swigc__p_raptor_locator, }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ /* ----------------------------------------------------------------------------- * Type initialization: * This problem is tough by the requirement that no dynamic * memory is used. Also, since swig_type_info structures store pointers to * swig_cast_info structures and swig_cast_info structures store pointers back * to swig_type_info structures, we need some lookup code at initialization. * The idea is that swig generates all the structures that are needed. * The runtime then collects these partially filled structures. * The SWIG_InitializeModule function takes these initial arrays out of * swig_module, and does all the lookup, filling in the swig_module.types * array with the correct data and linking the correct swig_cast_info * structures together. * * The generated swig_type_info structures are assigned statically to an initial * array. We just loop through that array, and handle each type individually. * First we lookup if this type has been already loaded, and if so, use the * loaded structure instead of the generated one. Then we have to fill in the * cast linked list. The cast data is initially stored in something like a * two-dimensional array. Each row corresponds to a type (there are the same * number of rows as there are in the swig_type_initial array). Each entry in * a column is one of the swig_cast_info structures for that type. * The cast_initial array is actually an array of arrays, because each row has * a variable number of columns. So to actually build the cast linked list, * we find the array of casts associated with the type, and loop through it * adding the casts to the list. The one last trick we need to do is making * sure the type pointer in the swig_cast_info struct is correct. * * First off, we lookup the cast->type name to see if it is already loaded. * There are three cases to handle: * 1) If the cast->type has already been loaded AND the type we are adding * casting info to has not been loaded (it is in this module), THEN we * replace the cast->type pointer with the type pointer that has already * been loaded. * 2) If BOTH types (the one we are adding casting info to, and the * cast->type) are loaded, THEN the cast info has already been loaded by * the previous module so we just ignore it. * 3) Finally, if cast->type has not already been loaded, then we add that * swig_cast_info to the linked list (because the cast->type) pointer will * be correct. * ----------------------------------------------------------------------------- */ #ifdef __cplusplus extern "C" { #if 0 } /* c-mode */ #endif #endif #if 0 #define SWIGRUNTIME_DEBUG #endif SWIGRUNTIME void SWIG_InitializeModule(void *clientdata) { size_t i; swig_module_info *module_head, *iter; int init; /* check to see if the circular list has been setup, if not, set it up */ if (swig_module.next==0) { /* Initialize the swig_module */ swig_module.type_initial = swig_type_initial; swig_module.cast_initial = swig_cast_initial; swig_module.next = &swig_module; init = 1; } else { init = 0; } /* Try and load any already created modules */ module_head = SWIG_GetModule(clientdata); if (!module_head) { /* This is the first module loaded for this interpreter */ /* so set the swig module into the interpreter */ SWIG_SetModule(clientdata, &swig_module); } else { /* the interpreter has loaded a SWIG module, but has it loaded this one? */ iter=module_head; do { if (iter==&swig_module) { /* Our module is already in the list, so there's nothing more to do. */ return; } iter=iter->next; } while (iter!= module_head); /* otherwise we must add our module into the list */ swig_module.next = module_head->next; module_head->next = &swig_module; } /* When multiple interpreters are used, a module could have already been initialized in a different interpreter, but not yet have a pointer in this interpreter. In this case, we do not want to continue adding types... everything should be set up already */ if (init == 0) return; /* Now work on filling in swig_module.types */ #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: size %d\n", swig_module.size); #endif for (i = 0; i < swig_module.size; ++i) { swig_type_info *type = 0; swig_type_info *ret; swig_cast_info *cast; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); #endif /* if there is another module already loaded */ if (swig_module.next != &swig_module) { type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); } if (type) { /* Overwrite clientdata field */ #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: found type %s\n", type->name); #endif if (swig_module.type_initial[i]->clientdata) { type->clientdata = swig_module.type_initial[i]->clientdata; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); #endif } } else { type = swig_module.type_initial[i]; } /* Insert casting types */ cast = swig_module.cast_initial[i]; while (cast->type) { /* Don't need to add information already in the list */ ret = 0; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); #endif if (swig_module.next != &swig_module) { ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); #ifdef SWIGRUNTIME_DEBUG if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); #endif } if (ret) { if (type == swig_module.type_initial[i]) { #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: skip old type %s\n", ret->name); #endif cast->type = ret; ret = 0; } else { /* Check for casting already in the list */ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); #ifdef SWIGRUNTIME_DEBUG if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); #endif if (!ocast) ret = 0; } } if (!ret) { #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); #endif if (type->cast) { type->cast->prev = cast; cast->next = type->cast; } type->cast = cast; } cast++; } /* Set entry in modules->types array equal to the type */ swig_module.types[i] = type; } swig_module.types[i] = 0; #ifdef SWIGRUNTIME_DEBUG printf("**** SWIG_InitializeModule: Cast List ******\n"); for (i = 0; i < swig_module.size; ++i) { int j = 0; swig_cast_info *cast = swig_module.cast_initial[i]; printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); while (cast->type) { printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); cast++; ++j; } printf("---- Total casts: %d\n",j); } printf("**** SWIG_InitializeModule: Cast List ******\n"); #endif } /* This function will propagate the clientdata field of type to * any new swig_type_info structures that have been added into the list * of equivalent types. It is like calling * SWIG_TypeClientData(type, clientdata) a second time. */ SWIGRUNTIME void SWIG_PropagateClientData(void) { size_t i; swig_cast_info *equiv; static int init_run = 0; if (init_run) return; init_run = 1; for (i = 0; i < swig_module.size; i++) { if (swig_module.types[i]->clientdata) { equiv = swig_module.types[i]->cast; while (equiv) { if (!equiv->converter) { if (equiv->type && !equiv->type->clientdata) SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); } equiv = equiv->next; } } } } #ifdef __cplusplus #if 0 { /* c-mode */ #endif } #endif SWIGEXPORT void SWIG_init(void) { /* compile-time include (inside a % ... % block) */ #ifdef REDLAND_INIT_I #include #endif } #include extern SEXP isnull(SEXP); SWIGINTERN R_CallMethodDef CallEntries[] = { {"isnull", (DL_FUNC) &isnull, 1}, {"R_swig_librdf_parser_set_feature", (DL_FUNC) &R_swig_librdf_parser_set_feature, 4}, {"R_swig_librdf_parser_get_feature", (DL_FUNC) &R_swig_librdf_parser_get_feature, 2}, {"R_swig_librdf_model_set_feature", (DL_FUNC) &R_swig_librdf_model_set_feature, 4}, {"R_swig_librdf_model_get_feature", (DL_FUNC) &R_swig_librdf_model_get_feature, 2}, {"R_swig_librdf_world_set_feature", (DL_FUNC) &R_swig_librdf_world_set_feature, 4}, {"R_swig_librdf_world_get_feature", (DL_FUNC) &R_swig_librdf_world_get_feature, 2}, {"R_swig_librdf_serializer_get_feature", (DL_FUNC) &R_swig_librdf_serializer_get_feature, 2}, {"R_swig_librdf_serializer_set_feature", (DL_FUNC) &R_swig_librdf_serializer_set_feature, 4}, {"R_swig_librdf_model_to_string", (DL_FUNC) &R_swig_librdf_model_to_string, 5}, {"R_swig_librdf_new_node_from_uri_string", (DL_FUNC) &R_swig_librdf_new_node_from_uri_string, 2}, {"R_swig_librdf_uri_to_string", (DL_FUNC) &R_swig_librdf_uri_to_string, 1}, {"R_swig_librdf_digest_update_string", (DL_FUNC) &R_swig_librdf_digest_update_string, 2}, {"R_swig_librdf_digest_to_string", (DL_FUNC) &R_swig_librdf_digest_to_string, 1}, {"R_swig_librdf_new_hash_from_string", (DL_FUNC) &R_swig_librdf_new_hash_from_string, 3}, {"R_swig_librdf_hash_to_string", (DL_FUNC) &R_swig_librdf_hash_to_string, 2}, {"R_swig_librdf_new_node_from_normalised_uri_string", (DL_FUNC) &R_swig_librdf_new_node_from_normalised_uri_string, 4}, {"R_swig_librdf_serializer_serialize_model_to_string", (DL_FUNC) &R_swig_librdf_serializer_serialize_model_to_string, 3}, {"R_swig_librdf_stream_end", (DL_FUNC) &R_swig_librdf_stream_end, 2}, {"R_swig_librdf_internal_test_error", (DL_FUNC) &R_swig_librdf_internal_test_error, 1}, {"R_swig_librdf_query_results_get_binding_name", (DL_FUNC) &R_swig_librdf_query_results_get_binding_name, 2}, {"R_swig_librdf_digest_init", (DL_FUNC) &R_swig_librdf_digest_init, 1}, {"R_swig_librdf_query_set_limit", (DL_FUNC) &R_swig_librdf_query_set_limit, 3}, {"R_swig_librdf_query_get_limit", (DL_FUNC) &R_swig_librdf_query_get_limit, 2}, {"R_swig_librdf_model_get_contexts", (DL_FUNC) &R_swig_librdf_model_get_contexts, 1}, {"R_swig_librdf_model_sync", (DL_FUNC) &R_swig_librdf_model_sync, 1}, {"R_swig_librdf_free_hash", (DL_FUNC) &R_swig_librdf_free_hash, 1}, {"R_swig_librdf_query_results_is_bindings", (DL_FUNC) &R_swig_librdf_query_results_is_bindings, 2}, {"R_swig_librdf_query_results_finished", (DL_FUNC) &R_swig_librdf_query_results_finished, 2}, {"R_swig_librdf_parser_get_accept_header", (DL_FUNC) &R_swig_librdf_parser_get_accept_header, 1}, {"R_swig_librdf_serializer_serialize_model_to_file", (DL_FUNC) &R_swig_librdf_serializer_serialize_model_to_file, 5}, {"R_swig_librdf_serializer_serialize_stream_to_file", (DL_FUNC) &R_swig_librdf_serializer_serialize_stream_to_file, 5}, {"R_swig_raptor_locator_uri", (DL_FUNC) &R_swig_raptor_locator_uri, 1}, {"R_swig_librdf_model_get_arcs_out", (DL_FUNC) &R_swig_librdf_model_get_arcs_out, 2}, {"R_swig_librdf_query_results_is_graph", (DL_FUNC) &R_swig_librdf_query_results_is_graph, 2}, {"R_swig_librdf_model_get_arc", (DL_FUNC) &R_swig_librdf_model_get_arc, 3}, {"R_swig_raptor_locator_byte", (DL_FUNC) &R_swig_raptor_locator_byte, 2}, {"R_swig_librdf_model_get_arcs_in", (DL_FUNC) &R_swig_librdf_model_get_arcs_in, 2}, {"R_swig_librdf_node_get_literal_value_as_latin1", (DL_FUNC) &R_swig_librdf_node_get_literal_value_as_latin1, 1}, {"R_swig_raptor_locator_file", (DL_FUNC) &R_swig_raptor_locator_file, 1}, {"R_swig_librdf_free_node", (DL_FUNC) &R_swig_librdf_free_node, 1}, {"R_swig_librdf_iterator_get_object", (DL_FUNC) &R_swig_librdf_iterator_get_object, 1}, {"R_swig_librdf_statement_get_object", (DL_FUNC) &R_swig_librdf_statement_get_object, 1}, {"R_swig_librdf_statement_set_object", (DL_FUNC) &R_swig_librdf_statement_set_object, 2}, {"R_swig_librdf_stream_get_object", (DL_FUNC) &R_swig_librdf_stream_get_object, 1}, {"R_swig_librdf_free_parser", (DL_FUNC) &R_swig_librdf_free_parser, 1}, {"R_swig_librdf_new_parser", (DL_FUNC) &R_swig_librdf_new_parser, 4}, {"R_swig_librdf_new_node_from_uri", (DL_FUNC) &R_swig_librdf_new_node_from_uri, 2}, {"R_swig_librdf_new_uri_from_uri", (DL_FUNC) &R_swig_librdf_new_uri_from_uri, 1}, {"R_swig_librdf_new_model_with_options", (DL_FUNC) &R_swig_librdf_new_model_with_options, 3}, {"R_swig_librdf_free_uri", (DL_FUNC) &R_swig_librdf_free_uri, 1}, {"R_swig_librdf_new_hash_from_array_of_strings", (DL_FUNC) &R_swig_librdf_new_hash_from_array_of_strings, 3}, {"R_swig_librdf_free_iterator", (DL_FUNC) &R_swig_librdf_free_iterator, 1}, {"R_swig_librdf_query_results_next", (DL_FUNC) &R_swig_librdf_query_results_next, 2}, {"R_swig_librdf_short_copyright_string_get", (DL_FUNC) &R_swig_librdf_short_copyright_string_get, 1}, {"R_swig_librdf_copyright_string_get", (DL_FUNC) &R_swig_librdf_copyright_string_get, 1}, {"R_swig_librdf_version_string_get", (DL_FUNC) &R_swig_librdf_version_string_get, 1}, {"R_swig_raptor_version_string_get", (DL_FUNC) &R_swig_raptor_version_string_get, 1}, {"R_swig_rasqal_version_string_get", (DL_FUNC) &R_swig_rasqal_version_string_get, 1}, {"R_swig_librdf_query_results_as_stream", (DL_FUNC) &R_swig_librdf_query_results_as_stream, 1}, {"R_swig_librdf_parser_parse_string_as_stream", (DL_FUNC) &R_swig_librdf_parser_parse_string_as_stream, 3}, {"R_swig_librdf_parser_parse_as_stream", (DL_FUNC) &R_swig_librdf_parser_parse_as_stream, 3}, {"R_swig_librdf_model_context_as_stream", (DL_FUNC) &R_swig_librdf_model_context_as_stream, 2}, {"R_swig_librdf_model_as_stream", (DL_FUNC) &R_swig_librdf_model_as_stream, 1}, {"R_swig_librdf_free_stream", (DL_FUNC) &R_swig_librdf_free_stream, 1}, {"R_swig_librdf_digest_update", (DL_FUNC) &R_swig_librdf_digest_update, 3}, {"R_swig_librdf_parser_parse_counted_string_into_model", (DL_FUNC) &R_swig_librdf_parser_parse_counted_string_into_model, 6}, {"R_swig_librdf_query_set_offset", (DL_FUNC) &R_swig_librdf_query_set_offset, 3}, {"R_swig_librdf_query_get_offset", (DL_FUNC) &R_swig_librdf_query_get_offset, 2}, {"R_swig_librdf_node_get_literal_value_is_wf_xml", (DL_FUNC) &R_swig_librdf_node_get_literal_value_is_wf_xml, 2}, {"R_swig_librdf_model_transaction_rollback", (DL_FUNC) &R_swig_librdf_model_transaction_rollback, 2}, {"R_swig_librdf_parser_guess_name2", (DL_FUNC) &R_swig_librdf_parser_guess_name2, 4}, {"R_swig_librdf_model_has_arc_in", (DL_FUNC) &R_swig_librdf_model_has_arc_in, 4}, {"R_swig_librdf_query_execute", (DL_FUNC) &R_swig_librdf_query_execute, 2}, {"R_swig_librdf_model_query_execute", (DL_FUNC) &R_swig_librdf_model_query_execute, 2}, {"R_swig_librdf_query_results_get_binding_value", (DL_FUNC) &R_swig_librdf_query_results_get_binding_value, 2}, {"R_swig_librdf_query_results_is_syntax", (DL_FUNC) &R_swig_librdf_query_results_is_syntax, 2}, {"R_swig_librdf_model_contains_context", (DL_FUNC) &R_swig_librdf_model_contains_context, 3}, {"R_swig_librdf_model_find_statements_in_context", (DL_FUNC) &R_swig_librdf_model_find_statements_in_context, 3}, {"R_swig_librdf_iterator_get_context", (DL_FUNC) &R_swig_librdf_iterator_get_context, 1}, {"R_swig_librdf_version_release_get", (DL_FUNC) &R_swig_librdf_version_release_get, 1}, {"R_swig_raptor_version_release_get", (DL_FUNC) &R_swig_raptor_version_release_get, 1}, {"R_swig_rasqal_version_release_get", (DL_FUNC) &R_swig_rasqal_version_release_get, 1}, {"R_swig_librdf_model_load", (DL_FUNC) &R_swig_librdf_model_load, 6}, {"R_swig_librdf_new_hash", (DL_FUNC) &R_swig_librdf_new_hash, 2}, {"R_swig_librdf_statement_is_complete", (DL_FUNC) &R_swig_librdf_statement_is_complete, 2}, {"R_swig_librdf_serializer_serialize_stream_to_string", (DL_FUNC) &R_swig_librdf_serializer_serialize_stream_to_string, 3}, {"R_swig_librdf_log_message_level", (DL_FUNC) &R_swig_librdf_log_message_level, 2}, {"R_swig_librdf_query_results_get_bindings_count", (DL_FUNC) &R_swig_librdf_query_results_get_bindings_count, 2}, {"R_swig_librdf_model_has_arc_out", (DL_FUNC) &R_swig_librdf_model_has_arc_out, 4}, {"R_swig_librdf_statement_get_predicate", (DL_FUNC) &R_swig_librdf_statement_get_predicate, 1}, {"R_swig_librdf_statement_set_predicate", (DL_FUNC) &R_swig_librdf_statement_set_predicate, 2}, {"R_swig_librdf_model_context_remove_statement", (DL_FUNC) &R_swig_librdf_model_context_remove_statement, 4}, {"R_swig_librdf_model_context_add_statement", (DL_FUNC) &R_swig_librdf_model_context_add_statement, 4}, {"R_swig_librdf_model_contains_statement", (DL_FUNC) &R_swig_librdf_model_contains_statement, 3}, {"R_swig_librdf_model_remove_statement", (DL_FUNC) &R_swig_librdf_model_remove_statement, 3}, {"R_swig_librdf_model_add_statement", (DL_FUNC) &R_swig_librdf_model_add_statement, 3}, {"R_swig_librdf_model_add_typed_literal_statement", (DL_FUNC) &R_swig_librdf_model_add_typed_literal_statement, 7}, {"R_swig_librdf_model_add_string_literal_statement", (DL_FUNC) &R_swig_librdf_model_add_string_literal_statement, 7}, {"R_swig_librdf_new_statement", (DL_FUNC) &R_swig_librdf_new_statement, 1}, {"R_swig_librdf_new_statement_from_statement", (DL_FUNC) &R_swig_librdf_new_statement_from_statement, 1}, {"R_swig_librdf_free_statement", (DL_FUNC) &R_swig_librdf_free_statement, 1}, {"R_swig_librdf_statement_match", (DL_FUNC) &R_swig_librdf_statement_match, 3}, {"R_swig_librdf_node_get_li_ordinal", (DL_FUNC) &R_swig_librdf_node_get_li_ordinal, 2}, {"R_swig_librdf_model_get_target", (DL_FUNC) &R_swig_librdf_model_get_target, 3}, {"R_swig_librdf_serializer_check_name", (DL_FUNC) &R_swig_librdf_serializer_check_name, 3}, {"R_swig_librdf_parser_check_name", (DL_FUNC) &R_swig_librdf_parser_check_name, 3}, {"R_swig_librdf_query_results_to_file2", (DL_FUNC) &R_swig_librdf_query_results_to_file2, 6}, {"R_swig_librdf_new_node_from_node", (DL_FUNC) &R_swig_librdf_new_node_from_node, 1}, {"R_swig_librdf_internal_test_warning", (DL_FUNC) &R_swig_librdf_internal_test_warning, 1}, {"R_swig_librdf_world_open", (DL_FUNC) &R_swig_librdf_world_open, 1}, {"R_swig_librdf_model_get_source", (DL_FUNC) &R_swig_librdf_model_get_source, 3}, {"R_swig_librdf_node_is_resource", (DL_FUNC) &R_swig_librdf_node_is_resource, 2}, {"R_swig_raptor_locator_column", (DL_FUNC) &R_swig_raptor_locator_column, 2}, {"R_swig_librdf_free_serializer", (DL_FUNC) &R_swig_librdf_free_serializer, 1}, {"R_swig_librdf_new_serializer", (DL_FUNC) &R_swig_librdf_new_serializer, 4}, {"R_swig_librdf_model_get_targets", (DL_FUNC) &R_swig_librdf_model_get_targets, 3}, {"R_swig_librdf_node_get_literal_value", (DL_FUNC) &R_swig_librdf_node_get_literal_value, 1}, {"R_swig_librdf_model_transaction_commit", (DL_FUNC) &R_swig_librdf_model_transaction_commit, 2}, {"R_swig_librdf_parser_parse_counted_string_as_stream", (DL_FUNC) &R_swig_librdf_parser_parse_counted_string_as_stream, 4}, {"R_swig_librdf_free_query_results", (DL_FUNC) &R_swig_librdf_free_query_results, 1}, {"R_swig_librdf_world_set_logger", (DL_FUNC) &R_swig_librdf_world_set_logger, 3}, {"R_swig_librdf_query_results_get_count", (DL_FUNC) &R_swig_librdf_query_results_get_count, 2}, {"R_swig_librdf_parser_get_namespaces_seen_count", (DL_FUNC) &R_swig_librdf_parser_get_namespaces_seen_count, 2}, {"R_swig_librdf_model_transaction_start", (DL_FUNC) &R_swig_librdf_model_transaction_start, 2}, {"R_swig_librdf_new_node", (DL_FUNC) &R_swig_librdf_new_node, 1}, {"R_swig_librdf_node_get_literal_value_language", (DL_FUNC) &R_swig_librdf_node_get_literal_value_language, 1}, {"R_swig_librdf_new_digest", (DL_FUNC) &R_swig_librdf_new_digest, 2}, {"R_swig_librdf_free_digest", (DL_FUNC) &R_swig_librdf_free_digest, 1}, {"R_swig_librdf_node_get_literal_value_datatype_uri", (DL_FUNC) &R_swig_librdf_node_get_literal_value_datatype_uri, 1}, {"R_swig_librdf_log_message_message", (DL_FUNC) &R_swig_librdf_log_message_message, 1}, {"R_swig_librdf_new_node_from_literal", (DL_FUNC) &R_swig_librdf_new_node_from_literal, 4}, {"R_swig_librdf_new_node_from_typed_literal", (DL_FUNC) &R_swig_librdf_new_node_from_typed_literal, 4}, {"R_swig_librdf_node_is_literal", (DL_FUNC) &R_swig_librdf_node_is_literal, 2}, {"R_swig_librdf_parser_parse_string_into_model", (DL_FUNC) &R_swig_librdf_parser_parse_string_into_model, 5}, {"R_swig_librdf_parser_parse_into_model", (DL_FUNC) &R_swig_librdf_parser_parse_into_model, 5}, {"R_swig_librdf_new_model", (DL_FUNC) &R_swig_librdf_new_model, 3}, {"R_swig_librdf_new_model_from_model", (DL_FUNC) &R_swig_librdf_new_model_from_model, 1}, {"R_swig_librdf_free_model", (DL_FUNC) &R_swig_librdf_free_model, 1}, {"R_swig_librdf_log_message_locator", (DL_FUNC) &R_swig_librdf_log_message_locator, 1}, {"R_swig_librdf_parser_get_namespaces_seen_prefix", (DL_FUNC) &R_swig_librdf_parser_get_namespaces_seen_prefix, 2}, {"R_swig_librdf_free_query", (DL_FUNC) &R_swig_librdf_free_query, 1}, {"R_swig_librdf_new_query_from_query", (DL_FUNC) &R_swig_librdf_new_query_from_query, 1}, {"R_swig_librdf_new_query", (DL_FUNC) &R_swig_librdf_new_query, 5}, {"R_swig_librdf_new_statement_from_nodes", (DL_FUNC) &R_swig_librdf_new_statement_from_nodes, 4}, {"R_swig_librdf_node_is_blank", (DL_FUNC) &R_swig_librdf_node_is_blank, 2}, {"R_swig_librdf_new_node_from_blank_identifier", (DL_FUNC) &R_swig_librdf_new_node_from_blank_identifier, 2}, {"R_swig_librdf_node_get_blank_identifier", (DL_FUNC) &R_swig_librdf_node_get_blank_identifier, 1}, {"R_swig_librdf_statement_get_subject", (DL_FUNC) &R_swig_librdf_statement_get_subject, 1}, {"R_swig_librdf_statement_set_subject", (DL_FUNC) &R_swig_librdf_statement_set_subject, 2}, {"R_swig_librdf_stream_next", (DL_FUNC) &R_swig_librdf_stream_next, 2}, {"R_swig_librdf_version_major_get", (DL_FUNC) &R_swig_librdf_version_major_get, 1}, {"R_swig_librdf_version_minor_get", (DL_FUNC) &R_swig_librdf_version_minor_get, 1}, {"R_swig_raptor_version_major_get", (DL_FUNC) &R_swig_raptor_version_major_get, 1}, {"R_swig_raptor_version_minor_get", (DL_FUNC) &R_swig_raptor_version_minor_get, 1}, {"R_swig_rasqal_version_major_get", (DL_FUNC) &R_swig_rasqal_version_major_get, 1}, {"R_swig_rasqal_version_minor_get", (DL_FUNC) &R_swig_rasqal_version_minor_get, 1}, {"R_swig_librdf_model_add", (DL_FUNC) &R_swig_librdf_model_add, 5}, {"R_swig_librdf_model_get_arcs", (DL_FUNC) &R_swig_librdf_model_get_arcs, 3}, {"R_swig_librdf_log_message_facility", (DL_FUNC) &R_swig_librdf_log_message_facility, 2}, {"R_swig_librdf_node_get_type", (DL_FUNC) &R_swig_librdf_node_get_type, 2}, {"R_swig_librdf_query_results_get_binding_value_by_name", (DL_FUNC) &R_swig_librdf_query_results_get_binding_value_by_name, 2}, {"R_swig_librdf_new_world", (DL_FUNC) &R_swig_librdf_new_world, 0}, {"R_swig_librdf_free_world", (DL_FUNC) &R_swig_librdf_free_world, 1}, {"R_swig_librdf_iterator_next", (DL_FUNC) &R_swig_librdf_iterator_next, 2}, {"R_swig_librdf_serializer_set_namespace", (DL_FUNC) &R_swig_librdf_serializer_set_namespace, 4}, {"R_swig_librdf_query_results_get_boolean", (DL_FUNC) &R_swig_librdf_query_results_get_boolean, 2}, {"R_swig_librdf_query_results_is_boolean", (DL_FUNC) &R_swig_librdf_query_results_is_boolean, 2}, {"R_swig_raptor_locator_line", (DL_FUNC) &R_swig_raptor_locator_line, 2}, {"R_swig_librdf_model_context_remove_statements", (DL_FUNC) &R_swig_librdf_model_context_remove_statements, 3}, {"R_swig_librdf_model_context_add_statements", (DL_FUNC) &R_swig_librdf_model_context_add_statements, 4}, {"R_swig_librdf_model_find_statements", (DL_FUNC) &R_swig_librdf_model_find_statements, 2}, {"R_swig_librdf_model_add_statements", (DL_FUNC) &R_swig_librdf_model_add_statements, 3}, {"R_swig_librdf_digest_final", (DL_FUNC) &R_swig_librdf_digest_final, 1}, {"R_swig_librdf_new_uri_from_filename", (DL_FUNC) &R_swig_librdf_new_uri_from_filename, 2}, {"R_swig_librdf_iterator_end", (DL_FUNC) &R_swig_librdf_iterator_end, 2}, {"R_swig_librdf_uri_equals", (DL_FUNC) &R_swig_librdf_uri_equals, 3}, {"R_swig_librdf_node_equals", (DL_FUNC) &R_swig_librdf_node_equals, 3}, {"R_swig_librdf_statement_equals", (DL_FUNC) &R_swig_librdf_statement_equals, 3}, {"R_swig_librdf_node_get_uri", (DL_FUNC) &R_swig_librdf_node_get_uri, 1}, {"R_swig_librdf_free_storage", (DL_FUNC) &R_swig_librdf_free_storage, 1}, {"R_swig_librdf_new_storage_from_storage", (DL_FUNC) &R_swig_librdf_new_storage_from_storage, 1}, {"R_swig_librdf_new_storage", (DL_FUNC) &R_swig_librdf_new_storage, 4}, {"R_swig_librdf_model_size", (DL_FUNC) &R_swig_librdf_model_size, 2}, {"R_swig_librdf_query_results_to_string2", (DL_FUNC) &R_swig_librdf_query_results_to_string2, 5}, {"R_swig_librdf_log_message_code", (DL_FUNC) &R_swig_librdf_log_message_code, 2}, {"R_swig_librdf_version_decimal_get", (DL_FUNC) &R_swig_librdf_version_decimal_get, 1}, {"R_swig_raptor_version_decimal_get", (DL_FUNC) &R_swig_raptor_version_decimal_get, 1}, {"R_swig_rasqal_version_decimal_get", (DL_FUNC) &R_swig_rasqal_version_decimal_get, 1}, {"R_swig_librdf_new_node_from_uri_local_name", (DL_FUNC) &R_swig_librdf_new_node_from_uri_local_name, 3}, {"R_swig_librdf_uri_compare", (DL_FUNC) &R_swig_librdf_uri_compare, 3}, {"R_swig_librdf_new_uri", (DL_FUNC) &R_swig_librdf_new_uri, 2}, {"R_swig_librdf_model_get_sources", (DL_FUNC) &R_swig_librdf_model_get_sources, 3}, {"R_swig_librdf_parser_get_namespaces_seen_uri", (DL_FUNC) &R_swig_librdf_parser_get_namespaces_seen_uri, 2}, {NULL, NULL, 0} }; SWIGEXPORT void R_init_redland(DllInfo *dll) { R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); } redland/NAMESPACE0000644000176200001440000002027414566244056013123 0ustar liggesusers# Generated by roxygen2: do not edit by hand S3method(roclet_output,roclet_mergeNamespace) S3method(roclet_process,roclet_mergeNamespace) S3method(roclet_tags,roclet_mergeNamespace) export(addStatement) export(executeQuery) export(freeModel) export(freeParser) export(freeQuery) export(freeQueryResults) export(freeSerializer) export(freeStatement) export(freeStorage) export(freeWorld) export(getBlankNodeId) export(getNodeType) export(getNodeValue) export(getQueryResultLimit) export(getResults) export(getTermType) export(is.null.externalptr) export(librdf_copyright_string) export(librdf_copyright_string_get) export(librdf_digest_final) export(librdf_digest_init) export(librdf_digest_to_string) export(librdf_digest_update) export(librdf_digest_update_string) export(librdf_free_digest) export(librdf_free_hash) export(librdf_free_iterator) export(librdf_free_model) export(librdf_free_node) export(librdf_free_parser) export(librdf_free_query) export(librdf_free_query_results) export(librdf_free_serializer) export(librdf_free_statement) export(librdf_free_storage) export(librdf_free_stream) export(librdf_free_uri) export(librdf_free_world) export(librdf_hash_to_string) export(librdf_internal_test_error) export(librdf_internal_test_warning) export(librdf_iterator_end) export(librdf_iterator_get_context) export(librdf_iterator_get_object) export(librdf_iterator_next) export(librdf_log_message_code) export(librdf_log_message_facility) export(librdf_log_message_level) export(librdf_log_message_locator) export(librdf_log_message_message) export(librdf_model_add) export(librdf_model_add_statement) export(librdf_model_add_statements) export(librdf_model_add_string_literal_statement) export(librdf_model_add_typed_literal_statement) export(librdf_model_as_stream) export(librdf_model_contains_context) export(librdf_model_contains_statement) export(librdf_model_context_add_statement) export(librdf_model_context_add_statements) export(librdf_model_context_as_stream) export(librdf_model_context_remove_statement) export(librdf_model_context_remove_statements) export(librdf_model_find_statements) export(librdf_model_find_statements_in_context) export(librdf_model_get_arc) export(librdf_model_get_arcs) export(librdf_model_get_arcs_in) export(librdf_model_get_arcs_out) export(librdf_model_get_contexts) export(librdf_model_get_feature) export(librdf_model_get_source) export(librdf_model_get_sources) export(librdf_model_get_target) export(librdf_model_get_targets) export(librdf_model_has_arc_in) export(librdf_model_has_arc_out) export(librdf_model_load) export(librdf_model_query_execute) export(librdf_model_remove_statement) export(librdf_model_set_feature) export(librdf_model_size) export(librdf_model_sync) export(librdf_model_to_string) export(librdf_model_transaction_commit) export(librdf_model_transaction_rollback) export(librdf_model_transaction_start) export(librdf_new_digest) export(librdf_new_hash) export(librdf_new_hash_from_array_of_strings) export(librdf_new_hash_from_string) export(librdf_new_model) export(librdf_new_model_from_model) export(librdf_new_model_with_options) export(librdf_new_node) export(librdf_new_node_from_blank_identifier) export(librdf_new_node_from_literal) export(librdf_new_node_from_node) export(librdf_new_node_from_normalised_uri_string) export(librdf_new_node_from_typed_literal) export(librdf_new_node_from_uri) export(librdf_new_node_from_uri_local_name) export(librdf_new_node_from_uri_string) export(librdf_new_parser) export(librdf_new_query) export(librdf_new_query_from_query) export(librdf_new_serializer) export(librdf_new_statement) export(librdf_new_statement_from_nodes) export(librdf_new_statement_from_statement) export(librdf_new_storage) export(librdf_new_storage_from_storage) export(librdf_new_uri) export(librdf_new_uri_from_filename) export(librdf_new_uri_from_uri) export(librdf_new_world) export(librdf_node_equals) export(librdf_node_get_blank_identifier) export(librdf_node_get_li_ordinal) export(librdf_node_get_literal_value) export(librdf_node_get_literal_value_as_latin1) export(librdf_node_get_literal_value_datatype_uri) export(librdf_node_get_literal_value_is_wf_xml) export(librdf_node_get_literal_value_language) export(librdf_node_get_type) export(librdf_node_get_uri) export(librdf_node_is_blank) export(librdf_node_is_literal) export(librdf_node_is_resource) export(librdf_parser_check_name) export(librdf_parser_get_accept_header) export(librdf_parser_get_feature) export(librdf_parser_get_namespaces_seen_count) export(librdf_parser_get_namespaces_seen_prefix) export(librdf_parser_get_namespaces_seen_uri) export(librdf_parser_guess_name2) export(librdf_parser_parse_as_stream) export(librdf_parser_parse_counted_string_as_stream) export(librdf_parser_parse_counted_string_into_model) export(librdf_parser_parse_into_model) export(librdf_parser_parse_string_as_stream) export(librdf_parser_parse_string_into_model) export(librdf_parser_set_feature) export(librdf_query_execute) export(librdf_query_get_limit) export(librdf_query_get_offset) export(librdf_query_results_as_stream) export(librdf_query_results_finished) export(librdf_query_results_get_binding_name) export(librdf_query_results_get_binding_value) export(librdf_query_results_get_binding_value_by_name) export(librdf_query_results_get_bindings_count) export(librdf_query_results_get_boolean) export(librdf_query_results_get_count) export(librdf_query_results_is_bindings) export(librdf_query_results_is_boolean) export(librdf_query_results_is_graph) export(librdf_query_results_is_syntax) export(librdf_query_results_next) export(librdf_query_results_to_file2) export(librdf_query_results_to_string2) export(librdf_query_set_limit) export(librdf_query_set_offset) export(librdf_serializer_check_name) export(librdf_serializer_get_feature) export(librdf_serializer_serialize_model_to_file) export(librdf_serializer_serialize_model_to_string) export(librdf_serializer_serialize_stream_to_file) export(librdf_serializer_serialize_stream_to_string) export(librdf_serializer_set_feature) export(librdf_serializer_set_namespace) export(librdf_short_copyright_string) export(librdf_short_copyright_string_get) export(librdf_statement_equals) export(librdf_statement_get_object) export(librdf_statement_get_predicate) export(librdf_statement_get_subject) export(librdf_statement_is_complete) export(librdf_statement_match) export(librdf_statement_set_object) export(librdf_statement_set_predicate) export(librdf_statement_set_subject) export(librdf_stream_end) export(librdf_stream_get_object) export(librdf_stream_next) export(librdf_uri_compare) export(librdf_uri_equals) export(librdf_uri_to_string) export(librdf_version_decimal) export(librdf_version_decimal_get) export(librdf_version_major) export(librdf_version_major_get) export(librdf_version_minor) export(librdf_version_minor_get) export(librdf_version_release) export(librdf_version_release_get) export(librdf_version_string) export(librdf_version_string_get) export(librdf_world_get_feature) export(librdf_world_open) export(librdf_world_set_feature) export(librdf_world_set_logger) export(mergeNamespace_roclet) export(parseFileIntoModel) export(raptor_locator_byte) export(raptor_locator_column) export(raptor_locator_file) export(raptor_locator_line) export(raptor_locator_uri) export(raptor_version_decimal) export(raptor_version_decimal_get) export(raptor_version_major) export(raptor_version_major_get) export(raptor_version_minor) export(raptor_version_minor_get) export(raptor_version_release) export(raptor_version_release_get) export(raptor_version_string) export(raptor_version_string_get) export(rasqal_version_decimal) export(rasqal_version_decimal_get) export(rasqal_version_major) export(rasqal_version_major_get) export(rasqal_version_minor) export(rasqal_version_minor_get) export(rasqal_version_release) export(rasqal_version_release_get) export(rasqal_version_string) export(rasqal_version_string_get) export(serializeToCharacter) export(serializeToFile) export(setNameSpace) export(setQueryResultLimit) export(writeResults) exportClasses(Model) exportClasses(Node) exportClasses(Parser) exportClasses(Query) exportClasses(QueryResults) exportClasses(Serializer) exportClasses(Statement) exportClasses(Storage) exportClasses(World) exportMethods(initialize) import(methods) import(roxygen2) useDynLib(redland, .registration = TRUE) redland/inst/0000755000176200001440000000000015116115726012645 5ustar liggesusersredland/inst/CITATION0000644000176200001440000000143512654701561014007 0ustar liggesusersyear <- sub("-.*", "", meta$Date) note <- sprintf("R package version %s", meta$Version) title <- meta$Title authors <- c(person("Matthew B.", "Jones", role = c("aut", "cre"), email = "jones@nceas.ucsb.edu"), person("Peter", "Slaughter", role = c("aut"), email = "slaughter@nceas.ucsb.edu"), person("Jeroen", "Ooms", role=c("aut"), email="jereonooms@gmail.com"), person("Carl", "Boettiger", role = c("aut"), email = "cboettig@gmail.com"), person("Scott", "Chamberlain", role = c("aut"), email = "myrmecocystus@gmail.com")) bibentry(bibtype = "Manual", title = paste0("{redland}: ", title), author = authors, year = year, note = note, url = "https://github.com/ropensci/redland-bindings/tree/master/R/redland", doi = "10.5063/F1VM496B") redland/inst/Makefile0000644000176200001440000004717315116115727014322 0ustar liggesusers# Makefile.in generated by automake 1.15 from Makefile.am. # Makefile. Generated from Makefile.in by configure. # Copyright (C) 1994-2014 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. # -*- Mode: Makefile -*- # # Makefile.am - automake file for R interface to Redland # # Copyright (C) 2014 Matthew Jones # Derived from code that was originally copyrighted: # Copyright (C) 2010 David Beckett - http://www.dajobe.org/ # And used under the terms of the Apache V2.0 license. # # This package is Free Software and part of Redland http://librdf.org/ # # It is licensed under the following three licenses as alternatives: # 1. GNU Lesser General Public License (LGPL) V2.1 or any newer version # 2. GNU General Public License (GPL) V2 or any newer version # 3. Apache License, V2.0 or any newer version # # You may not use this file except in compliance with at least one of # the above three licenses. # # See LICENSE.html or LICENSE.txt at the top of this package for the # full license terms. # am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/redland pkgincludedir = $(includedir)/redland pkglibdir = $(libdir)/redland pkglibexecdir = $(libexecdir)/redland am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : subdir = . ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \ $(am__configure_deps) $(am__DIST_COMMON) am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = AM_V_P = $(am__v_P_$(V)) am__v_P_ = $(am__v_P_$(AM_DEFAULT_VERBOSITY)) am__v_P_0 = false am__v_P_1 = : AM_V_GEN = $(am__v_GEN_$(V)) am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) am__v_GEN_0 = @echo " GEN " $@; am__v_GEN_1 = AM_V_at = $(am__v_at_$(V)) am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY)) am__v_at_0 = @ am__v_at_1 = SOURCES = DIST_SOURCES = am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) am__DIST_COMMON = $(srcdir)/Makefile.in COPYING INSTALL NEWS README \ compile install-sh ltmain.sh missing DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) am__remove_distdir = \ if test -d "$(distdir)"; then \ find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ && rm -rf "$(distdir)" \ || { sleep 5 && rm -rf "$(distdir)"; }; \ else :; fi am__post_remove_distdir = $(am__remove_distdir) DIST_ARCHIVES = $(distdir).tar.gz GZIP_ENV = --best DIST_TARGETS = dist-gzip distuninstallcheck_listfiles = find . -type f -print am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' distcleancheck_listfiles = find . -type f -print ACLOCAL = ${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing aclocal-1.15 AMTAR = $${TAR-tar} AM_DEFAULT_VERBOSITY = 1 AUTOCONF = ${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing autoconf AUTOHEADER = ${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing autoheader AUTOMAKE = ${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing automake-1.15 AWK = gawk CC = gcc CCDEPMODE = depmode=none CFLAGS = -g -O2 CPP = gcc -E CPPFLAGS = CYGPATH_W = echo DEFS = -DPACKAGE_NAME=\"redland\" -DPACKAGE_TARNAME=\"redland\" -DPACKAGE_VERSION=\"1.0.14\" -DPACKAGE_STRING=\"redland\ 1.0.14\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DPACKAGE=\"redland\" -DVERSION=\"1.0.14\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_LIMITS_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_STDLIB_H=1 -DHAVE_MALLOC=1 -DHAVE_MEMSET=1 DEPDIR = .deps ECHO_C = \c ECHO_N = ECHO_T = EGREP = /usr/bin/grep -E EXEEXT = GREP = /usr/bin/grep INSTALL = /opt/local/bin/ginstall -c INSTALL_DATA = ${INSTALL} -m 644 INSTALL_PROGRAM = ${INSTALL} INSTALL_SCRIPT = ${INSTALL} INSTALL_STRIP_PROGRAM = $(install_sh) -c -s LDFLAGS = LIBOBJS = LIBRDF_CPPFLAGS = -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 LIBRDF_LDFLAGS = -L/opt/local/lib -lrdf LIBS = $(SRCDIR)/redland.so LTLIBOBJS = MAINT = # MAKEINFO = ${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing makeinfo MKDIR_P = /opt/local/bin/gmkdir -p OBJEXT = o PACKAGE = redland PACKAGE_BUGREPORT = PACKAGE_NAME = redland PACKAGE_STRING = redland 1.0.14 PACKAGE_TARNAME = redland PACKAGE_URL = PACKAGE_VERSION = 1.0.14 PATH_SEPARATOR = : PKG_CONFIG = pkg-config R = R RAPTOR_LDFLAGS = -L/opt/local/lib -lraptor2 RASQAL_LDFLAGS = -L/opt/local/lib -lrasqal -lraptor2 SET_MAKE = SHELL = /bin/sh STRIP = VERSION = 1.0.14 abs_builddir = /Users/jones/development/redland-bindings/R/redland/inst abs_srcdir = /Users/jones/development/redland-bindings/R/redland/inst abs_top_builddir = /Users/jones/development/redland-bindings/R/redland/inst abs_top_srcdir = /Users/jones/development/redland-bindings/R/redland/inst ac_ct_CC = gcc am__include = include am__leading_dot = . am__quote = am__tar = $${TAR-tar} chof - "$$tardir" am__untar = $${TAR-tar} xf - bindir = ${exec_prefix}/bin build_alias = builddir = . datadir = ${datarootdir} datarootdir = ${prefix}/share docdir = ${datarootdir}/doc/${PACKAGE_TARNAME} dvidir = ${docdir} exec_prefix = ${prefix} host_alias = htmldir = ${docdir} includedir = ${prefix}/include infodir = ${datarootdir}/info install_sh = ${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/install-sh libdir = ${exec_prefix}/lib libexecdir = ${exec_prefix}/libexec localedir = ${datarootdir}/locale localstatedir = ${prefix}/var mandir = ${datarootdir}/man mkdir_p = $(MKDIR_P) oldincludedir = /usr/include pdfdir = ${docdir} prefix = /usr/local program_transform_name = s,x,x, psdir = ${docdir} sbindir = ${exec_prefix}/sbin sharedstatedir = ${prefix}/com srcdir = . sysconfdir = ${prefix}/etc target_alias = top_build_prefix = top_builddir = . top_srcdir = . SRCDIR = ../src SRCS = $(SRCDIR)/redland.c $(SRCDIR)/util.c MAKEVARS = $(SRCDIR)/Makevars CLEAN_FILES = aclocal.m4 \ autoscan.log \ config.h \ ../src/redland.o \ stamp-h1 \ ../src/util.o \ autom4te.cache \ config.h.in \ config.log \ Makefile \ ltmain.sh \ config.status all: all-am .SUFFIXES: am--refresh: Makefile @: $(srcdir)/Makefile.in: # $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \ $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \ && exit 0; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ echo ' $(SHELL) ./config.status'; \ $(SHELL) ./config.status;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) $(SHELL) ./config.status --recheck $(top_srcdir)/configure: # $(am__configure_deps) $(am__cd) $(srcdir) && $(AUTOCONF) $(ACLOCAL_M4): # $(am__aclocal_m4_deps) $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) $(am__aclocal_m4_deps): tags TAGS: ctags CTAGS: cscope cscopelist: distdir: $(DISTFILES) $(am__remove_distdir) test -d "$(distdir)" || mkdir "$(distdir)" @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ dist_files=`for file in $$list; do echo $$file; done | \ sed -e "s|^$$srcdirstrip/||;t" \ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ case $$dist_files in \ */*) $(MKDIR_P) `echo "$$dist_files" | \ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ sort -u` ;; \ esac; \ for file in $$dist_files; do \ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ if test -d $$d/$$file; then \ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ if test -d "$(distdir)/$$file"; then \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ else \ test -f "$(distdir)/$$file" \ || cp -p $$d/$$file "$(distdir)/$$file" \ || exit 1; \ fi; \ done -test -n "$(am__skip_mode_fix)" \ || find "$(distdir)" -type d ! -perm -755 \ -exec chmod u+rwx,go+rx {} \; -o \ ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ || chmod -R a+r "$(distdir)" dist-gzip: distdir tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz $(am__post_remove_distdir) dist-bzip2: distdir tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 $(am__post_remove_distdir) dist-lzip: distdir tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz $(am__post_remove_distdir) dist-xz: distdir tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz $(am__post_remove_distdir) dist-tarZ: distdir @echo WARNING: "Support for distribution archives compressed with" \ "legacy program 'compress' is deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z $(am__post_remove_distdir) dist-shar: distdir @echo WARNING: "Support for shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz $(am__post_remove_distdir) dist-zip: distdir -rm -f $(distdir).zip zip -rq $(distdir).zip $(distdir) $(am__post_remove_distdir) dist dist-all: $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' $(am__post_remove_distdir) # This target untars the dist file and tries a VPATH configuration. Then # it guarantees that the distribution is self-contained by making another # tarfile. distcheck: dist case '$(DIST_ARCHIVES)' in \ *.tar.gz*) \ GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ *.tar.bz2*) \ bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ *.tar.lz*) \ lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ *.tar.xz*) \ xz -dc $(distdir).tar.xz | $(am__untar) ;;\ *.tar.Z*) \ uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ *.shar.gz*) \ GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\ *.zip*) \ unzip $(distdir).zip ;;\ esac chmod -R a-w $(distdir) chmod u+w $(distdir) mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst chmod a-w $(distdir) test -d $(distdir)/_build || exit 0; \ dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ && am__cwd=`pwd` \ && $(am__cd) $(distdir)/_build/sub \ && ../../configure \ $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ --srcdir=../.. --prefix="$$dc_install_base" \ && $(MAKE) $(AM_MAKEFLAGS) \ && $(MAKE) $(AM_MAKEFLAGS) dvi \ && $(MAKE) $(AM_MAKEFLAGS) check \ && $(MAKE) $(AM_MAKEFLAGS) install \ && $(MAKE) $(AM_MAKEFLAGS) installcheck \ && $(MAKE) $(AM_MAKEFLAGS) uninstall \ && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ distuninstallcheck \ && chmod -R a-w "$$dc_install_base" \ && ({ \ (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ } || { rm -rf "$$dc_destdir"; exit 1; }) \ && rm -rf "$$dc_destdir" \ && $(MAKE) $(AM_MAKEFLAGS) dist \ && rm -rf $(DIST_ARCHIVES) \ && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ && cd "$$am__cwd" \ || exit 1 $(am__post_remove_distdir) @(echo "$(distdir) archives ready for distribution: "; \ list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' distuninstallcheck: @test -n '$(distuninstallcheck_dir)' || { \ echo 'ERROR: trying to run $@ with an empty' \ '$$(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ $(am__cd) '$(distuninstallcheck_dir)' || { \ echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left after uninstall:" ; \ if test -n "$(DESTDIR)"; then \ echo " (check DESTDIR support)"; \ fi ; \ $(distuninstallcheck_listfiles) ; \ exit 1; } >&2 distcleancheck: distclean @if test '$(srcdir)' = . ; then \ echo "ERROR: distcleancheck can only run from a VPATH build" ; \ exit 1 ; \ fi @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left in build directory after distclean:" ; \ $(distcleancheck_listfiles) ; \ exit 1; } >&2 check-am: all-am check: check-am all-am: Makefile installdirs: install: install-am install-exec: install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: if test -z '$(STRIP)'; then \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ install; \ else \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ fi mostlyclean-generic: clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." clean: clean-am clean-am: clean-generic mostlyclean-am distclean: distclean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -f Makefile distclean-am: clean-am distclean-generic dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-dvi: install-dvi-am install-dvi-am: install-exec-am: install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-generic pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: .MAKE: install-am install-strip .PHONY: all all-am am--refresh check check-am clean clean-generic \ cscopelist-am ctags-am dist dist-all dist-bzip2 dist-gzip \ dist-lzip dist-shar dist-tarZ dist-xz dist-zip distcheck \ distclean distclean-generic distcleancheck distdir \ distuninstallcheck dvi dvi-am html html-am info info-am \ install install-am install-data install-data-am install-dvi \ install-dvi-am install-exec install-exec-am install-html \ install-html-am install-info install-info-am install-man \ install-pdf install-pdf-am install-ps install-ps-am \ install-strip installcheck installcheck-am installdirs \ maintainer-clean maintainer-clean-generic mostlyclean \ mostlyclean-generic pdf pdf-am ps ps-am tags-am uninstall \ uninstall-am .PRECIOUS: Makefile $(LIBS): $(SRCS) -echo "PKG_CFLAGS = -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 " > $(MAKEVARS) -echo "PKG_LIBS = -L/opt/local/lib -lrdf -L/opt/local/lib -lrasqal -lraptor2 " >> $(MAKEVARS) cd $(SRCDIR) && R CMD SHLIB redland.c util.c #$(MAKEVARS): # -echo "PKG_CFLAGS = -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 " > $@ # -echo "PKG_LIBS = -L/opt/local/lib -lrdf -L/opt/local/lib -lrasqal -lraptor2 " >> $@ all: ${LIBS} dev-clean: rm -f $(MAKEVARS) ; \ rm -f $(LIBS) ; \ for fname in $(CLEAN_FILES); do \ if [ -d "$$fname" ]; then \ rm -f $$fname/* ; \ rmdir $$fname ; \ else \ if [ -e "$$fname" ]; then rm -f $$fname ; fi \ fi \ done; # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: redland/inst/doc/0000755000176200001440000000000015116115726013412 5ustar liggesusersredland/inst/doc/redland_overview.Rmd0000644000176200001440000000474114433104445017420 0ustar liggesusers--- title: "redland: create, query and write RDF graphs" author: "Peter Slaughter" date: "`r Sys.Date()`" output: rmarkdown::html_vignette vignette: > %\VignetteIndexEntry{redland RDF} %\VignetteEngine{knitr::rmarkdown} %\VignetteEncoding{UTF-8} --- ## Introduction The `redland` R package provides methods to create, query and write to disk data stored in the Resource Description Framework (RDF). RDF provides a standardized way to make statements about resources and the relationships between them. Typical resources include datasets that are available via URLs. Resources don't have to be available online, for example a resource could also be the name of the person that created a dataset. A collection of RDF statements comprise an RDF graph, which can be read and interpreted by an RDF capable software application that uses the resources described in the graph. An introduction to RDF can be found at https://www.w3.org/TR/2014/NOTE-rdf11-primer-20140624/. ## Examples The following example reads an RDF graph from a disk file that was previously saved in the RDF/XML format: ```{r} library(redland) world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world=world, storage, options="") parser <- new("Parser", world) parseFileIntoModel(parser, world, system.file("extdata", "dc.rdf", package="redland"), model) ``` Next the RDF graph is queried for statements of interest, using the [SPARQL query syntax](https://www.w3.org/TR/rdf-sparql-query/) ```{r} queryString <- 'PREFIX dc: SELECT ?a ?c WHERE { ?a dc:creator ?c . }' query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) queryResult <- executeQuery(query, model) results <- getResults(query, model, "rdfxml") cat(sprintf("Results from query: %s\n", results)) ``` Next, additional statements can be added to the RDF graph: ```{r} stmt <- new("Statement", world=world, subject="http://www.dajobe.org/", predicate="http://purl.org/dc/elements/1.1/language", object="en") addStatement(model, stmt) ``` Now the RDF graph can be written to disk: ```{r} serializer <- new("Serializer", world, mimeType="application/rdf+xml") status <- setNameSpace(serializer, world, namespace="http://purl.org/dc/elements/1.1/", prefix="dc") filePath <- tempfile(pattern = "file", tmpdir = tempdir(), fileext = ".rdf") status <- serializeToFile(serializer, world, model, filePath) ``` redland/inst/doc/redland_overview.R0000644000176200001440000000270615116115726017101 0ustar liggesusers## ----------------------------------------------------------------------------- library(redland) world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world=world, storage, options="") parser <- new("Parser", world) parseFileIntoModel(parser, world, system.file("extdata", "dc.rdf", package="redland"), model) ## ----------------------------------------------------------------------------- queryString <- 'PREFIX dc: SELECT ?a ?c WHERE { ?a dc:creator ?c . }' query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) queryResult <- executeQuery(query, model) results <- getResults(query, model, "rdfxml") cat(sprintf("Results from query: %s\n", results)) ## ----------------------------------------------------------------------------- stmt <- new("Statement", world=world, subject="http://www.dajobe.org/", predicate="http://purl.org/dc/elements/1.1/language", object="en") addStatement(model, stmt) ## ----------------------------------------------------------------------------- serializer <- new("Serializer", world, mimeType="application/rdf+xml") status <- setNameSpace(serializer, world, namespace="http://purl.org/dc/elements/1.1/", prefix="dc") filePath <- tempfile(pattern = "file", tmpdir = tempdir(), fileext = ".rdf") status <- serializeToFile(serializer, world, model, filePath) redland/inst/doc/redland_overview.html0000644000176200001440000003737015116115726017651 0ustar liggesusers redland: create, query and write RDF graphs

redland: create, query and write RDF graphs

Peter Slaughter

2025-12-09

Introduction

The redland R package provides methods to create, query and write to disk data stored in the Resource Description Framework (RDF). RDF provides a standardized way to make statements about resources and the relationships between them. Typical resources include datasets that are available via URLs. Resources don’t have to be available online, for example a resource could also be the name of the person that created a dataset. A collection of RDF statements comprise an RDF graph, which can be read and interpreted by an RDF capable software application that uses the resources described in the graph.

An introduction to RDF can be found at https://www.w3.org/TR/2014/NOTE-rdf11-primer-20140624/.

Examples

The following example reads an RDF graph from a disk file that was previously saved in the RDF/XML format:

library(redland)
world <- new("World")
storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'")
model <- new("Model", world=world, storage, options="")
parser <- new("Parser", world)
parseFileIntoModel(parser, world, system.file("extdata", "dc.rdf", package="redland"), model)

Next the RDF graph is queried for statements of interest, using the SPARQL query syntax

queryString <- 'PREFIX dc: <http://purl.org/dc/elements/1.1/> SELECT ?a ?c WHERE { ?a dc:creator ?c . }'
query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL)
queryResult <- executeQuery(query, model)
results <- getResults(query, model, "rdfxml")

cat(sprintf("Results from query: %s\n", results))
## Results from query: <?xml version="1.0" encoding="utf-8"?>
## <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
##    xmlns:rs="http://www.w3.org/2001/sw/DataAccess/tests/result-set#">
##   <rs:ResultSet>
##     <rs:resultVariable>a</rs:resultVariable>
##     <rs:resultVariable>c</rs:resultVariable>
##     <rs:solution>
##       <rdf:Description>
##         <rs:binding>
##           <rdf:Description>
##             <rs:value rdf:resource="http://www.dajobe.org/"/>
##             <rs:variable>a</rs:variable>
##           </rdf:Description>
##         </rs:binding>
##         <rs:binding>
##           <rdf:Description>
##             <rs:value>Dave Beckett</rs:value>
##             <rs:variable>c</rs:variable>
##           </rdf:Description>
##         </rs:binding>
##       </rdf:Description>
##     </rs:solution>
##   </rs:ResultSet>
## </rdf:RDF>

Next, additional statements can be added to the RDF graph:

stmt <- new("Statement", world=world, 
        subject="http://www.dajobe.org/",
        predicate="http://purl.org/dc/elements/1.1/language",
        object="en")
addStatement(model, stmt)
## [1] 0

Now the RDF graph can be written to disk:

serializer <- new("Serializer", world, mimeType="application/rdf+xml")
status <- setNameSpace(serializer, world, namespace="http://purl.org/dc/elements/1.1/", prefix="dc")  
filePath <- tempfile(pattern = "file", tmpdir = tempdir(), fileext = ".rdf")
status <- serializeToFile(serializer, world, model, filePath)
redland/inst/config.log0000644000176200001440000004533612535362125014627 0ustar liggesusersThis file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by redland configure 1.0.14, which was generated by GNU Autoconf 2.69. Invocation command line was $ ./configure ## --------- ## ## Platform. ## ## --------- ## hostname = frost.local uname -m = x86_64 uname -r = 14.3.0 uname -s = Darwin uname -v = Darwin Kernel Version 14.3.0: Mon Mar 23 11:59:05 PDT 2015; root:xnu-2782.20.48~5/RELEASE_X86_64 /usr/bin/uname -p = i386 /bin/uname -X = unknown /bin/arch = unknown /usr/bin/arch -k = unknown /usr/convex/getsysinfo = unknown /usr/bin/hostinfo = Mach kernel version: Darwin Kernel Version 14.3.0: Mon Mar 23 11:59:05 PDT 2015; root:xnu-2782.20.48~5/RELEASE_X86_64 Kernel configured for up to 8 processors. 4 processors are physically available. 8 processors are logically available. Processor type: x86_64h (Intel x86-64h Haswell) Processors active: 0 1 2 3 4 5 6 7 Primary memory available: 16.00 gigabytes Default processor set: 314 tasks, 1698 threads, 8 processors Load average: 1.51, Mach factor: 6.48 /bin/machine = unknown /usr/bin/oslevel = unknown /bin/universe = unknown PATH: /opt/local/bin PATH: /opt/local/sbin PATH: /Users/jones/.rvm/gems/ruby-2.1.1/bin PATH: /Users/jones/.rvm/gems/ruby-2.1.1@global/bin PATH: /Users/jones/.rvm/rubies/ruby-2.1.1/bin PATH: /Library/Java/JavaVirtualMachines/jdk1.7.0_60.jdk/Contents/Home/bin PATH: /Library/Anaconda/bin PATH: /usr/local/bin PATH: /usr/bin PATH: /bin PATH: /usr/sbin PATH: /sbin PATH: /Library/anaconda/bin PATH: /usr/local/sbin PATH: /opt/local/bin PATH: /opt/local/sbin PATH: /opt/local/lib/postgresql84/bin/ PATH: /Users/jones/development/dataone/allsoftware/tools/docutils PATH: /usr/texbin PATH: /Users/jones/.rvm/bin ## ----------- ## ## Core tests. ## ## ----------- ## configure:2252: checking for a BSD-compatible install configure:2320: result: /opt/local/bin/ginstall -c configure:2331: checking whether build environment is sane configure:2386: result: yes configure:2537: checking for a thread-safe mkdir -p configure:2576: result: /opt/local/bin/gmkdir -p configure:2583: checking for gawk configure:2599: found /opt/local/bin/gawk configure:2610: result: gawk configure:2621: checking whether make sets $(MAKE) configure:2643: result: yes configure:2672: checking whether make supports nested variables configure:2689: result: yes configure:2817: checking whether to enable maintainer-specific portions of Makefiles configure:2826: result: no configure:2892: checking for gcc configure:2908: found /usr/bin/gcc configure:2919: result: gcc configure:3148: checking for C compiler version configure:3157: gcc --version >&5 Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn) Target: x86_64-apple-darwin14.3.0 Thread model: posix Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1 configure:3168: $? = 0 configure:3157: gcc -v >&5 Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1 Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn) Target: x86_64-apple-darwin14.3.0 Thread model: posix configure:3168: $? = 0 configure:3157: gcc -V >&5 clang: error: argument to '-V' is missing (expected 1 value) clang: error: no input files configure:3168: $? = 1 configure:3157: gcc -qversion >&5 clang: error: unknown argument: '-qversion' clang: error: no input files configure:3168: $? = 1 configure:3188: checking whether the C compiler works configure:3210: gcc conftest.c >&5 configure:3214: $? = 0 configure:3262: result: yes configure:3265: checking for C compiler default output file name configure:3267: result: a.out configure:3273: checking for suffix of executables configure:3280: gcc -o conftest conftest.c >&5 configure:3284: $? = 0 configure:3306: result: configure:3328: checking whether we are cross compiling configure:3336: gcc -o conftest conftest.c >&5 configure:3340: $? = 0 configure:3347: ./conftest configure:3351: $? = 0 configure:3366: result: no configure:3371: checking for suffix of object files configure:3393: gcc -c conftest.c >&5 configure:3397: $? = 0 configure:3418: result: o configure:3422: checking whether we are using the GNU C compiler configure:3441: gcc -c conftest.c >&5 configure:3441: $? = 0 configure:3450: result: yes configure:3459: checking whether gcc accepts -g configure:3479: gcc -c -g conftest.c >&5 configure:3479: $? = 0 configure:3520: result: yes configure:3537: checking for gcc option to accept ISO C89 configure:3600: gcc -c -g -O2 conftest.c >&5 configure:3600: $? = 0 configure:3613: result: none needed configure:3638: checking whether gcc understands -c and -o together configure:3660: gcc -c conftest.c -o conftest2.o configure:3663: $? = 0 configure:3660: gcc -c conftest.c -o conftest2.o configure:3663: $? = 0 configure:3675: result: yes configure:3703: checking for style of include used by make configure:3731: result: GNU configure:3757: checking dependency style of gcc configure:3868: result: none configure:3888: checking for R configure:3904: found /usr/bin/R configure:3915: result: R configure:3930: checking for pkg-config configure:3946: found /opt/local/bin/pkg-config configure:3957: result: pkg-config configure:3970: checking for redland configure:3977: result: 1.0.15 configure:3993: checking for raptor_parse in -lraptor2 configure:4018: gcc -o conftest -g -O2 conftest.c -lraptor2 >&5 ld: library not found for -lraptor2 clang: error: linker command failed with exit code 1 (use -v to see invocation) configure:4018: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | /* end confdefs.h. */ | | /* Override any GCC internal prototype to avoid an error. | Use char because int might match the return type of a GCC | builtin and then its argument prototype would still apply. */ | #ifdef __cplusplus | extern "C" | #endif | char raptor_parse (); | int | main () | { | return raptor_parse (); | ; | return 0; | } configure:4027: result: no configure:4038: checking for rasqal_new_world in -lrasqal configure:4063: gcc -o conftest -g -O2 conftest.c -lrasqal >&5 ld: library not found for -lrasqal clang: error: linker command failed with exit code 1 (use -v to see invocation) configure:4063: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | /* end confdefs.h. */ | | /* Override any GCC internal prototype to avoid an error. | Use char because int might match the return type of a GCC | builtin and then its argument prototype would still apply. */ | #ifdef __cplusplus | extern "C" | #endif | char rasqal_new_world (); | int | main () | { | return rasqal_new_world (); | ; | return 0; | } configure:4072: result: no configure:4090: checking how to run the C preprocessor configure:4121: gcc -E conftest.c configure:4121: $? = 0 configure:4135: gcc -E conftest.c conftest.c:11:10: fatal error: 'ac_nonexistent.h' file not found #include ^ 1 error generated. configure:4135: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | /* end confdefs.h. */ | #include configure:4160: result: gcc -E configure:4180: gcc -E conftest.c configure:4180: $? = 0 configure:4194: gcc -E conftest.c conftest.c:11:10: fatal error: 'ac_nonexistent.h' file not found #include ^ 1 error generated. configure:4194: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | /* end confdefs.h. */ | #include configure:4223: checking for grep that handles long lines and -e configure:4281: result: /usr/bin/grep configure:4286: checking for egrep configure:4348: result: /usr/bin/grep -E configure:4353: checking for ANSI C header files configure:4373: gcc -c -g -O2 conftest.c >&5 configure:4373: $? = 0 configure:4446: gcc -o conftest -g -O2 conftest.c >&5 configure:4446: $? = 0 configure:4446: ./conftest configure:4446: $? = 0 configure:4457: result: yes configure:4470: checking for sys/types.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for sys/stat.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for stdlib.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for string.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for memory.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for strings.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for inttypes.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for stdint.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for unistd.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4485: checking limits.h usability configure:4485: gcc -c -g -O2 conftest.c >&5 configure:4485: $? = 0 configure:4485: result: yes configure:4485: checking limits.h presence configure:4485: gcc -E conftest.c configure:4485: $? = 0 configure:4485: result: yes configure:4485: checking for limits.h configure:4485: result: yes configure:4485: checking for stdlib.h configure:4485: result: yes configure:4485: checking for string.h configure:4485: result: yes configure:4497: checking for size_t configure:4497: gcc -c -g -O2 conftest.c >&5 configure:4497: $? = 0 configure:4497: gcc -c -g -O2 conftest.c >&5 conftest.c:60:21: error: expected expression if (sizeof ((size_t))) ^ 1 error generated. configure:4497: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | #define STDC_HEADERS 1 | #define HAVE_SYS_TYPES_H 1 | #define HAVE_SYS_STAT_H 1 | #define HAVE_STDLIB_H 1 | #define HAVE_STRING_H 1 | #define HAVE_MEMORY_H 1 | #define HAVE_STRINGS_H 1 | #define HAVE_INTTYPES_H 1 | #define HAVE_STDINT_H 1 | #define HAVE_UNISTD_H 1 | #define HAVE_LIMITS_H 1 | #define HAVE_STDLIB_H 1 | #define HAVE_STRING_H 1 | /* end confdefs.h. */ | #include | #ifdef HAVE_SYS_TYPES_H | # include | #endif | #ifdef HAVE_SYS_STAT_H | # include | #endif | #ifdef STDC_HEADERS | # include | # include | #else | # ifdef HAVE_STDLIB_H | # include | # endif | #endif | #ifdef HAVE_STRING_H | # if !defined STDC_HEADERS && defined HAVE_MEMORY_H | # include | # endif | # include | #endif | #ifdef HAVE_STRINGS_H | # include | #endif | #ifdef HAVE_INTTYPES_H | # include | #endif | #ifdef HAVE_STDINT_H | # include | #endif | #ifdef HAVE_UNISTD_H | # include | #endif | int | main () | { | if (sizeof ((size_t))) | return 0; | ; | return 0; | } configure:4497: result: yes configure:4512: checking for stdlib.h configure:4512: result: yes configure:4522: checking for GNU libc compatible malloc configure:4546: gcc -o conftest -g -O2 conftest.c >&5 configure:4546: $? = 0 configure:4546: ./conftest configure:4546: $? = 0 configure:4556: result: yes configure:4579: checking for memset configure:4579: gcc -o conftest -g -O2 conftest.c >&5 conftest.c:49:6: warning: incompatible redeclaration of library function 'memset' [-Wincompatible-library-redeclaration] char memset (); ^ conftest.c:49:6: note: 'memset' is a builtin with type 'void *(void *, int, unsigned long)' 1 warning generated. configure:4579: $? = 0 configure:4579: result: yes configure:4749: checking that generated files are newer than configure configure:4755: result: done configure:4782: creating ./config.status ## ---------------------- ## ## Running config.status. ## ## ---------------------- ## This file was extended by redland config.status 1.0.14, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = CONFIG_HEADERS = CONFIG_LINKS = CONFIG_COMMANDS = $ ./config.status on frost.local config.status:786: creating Makefile config.status:958: executing depfiles commands ## ---------------- ## ## Cache variables. ## ## ---------------- ## ac_cv_c_compiler_gnu=yes ac_cv_env_CC_set= ac_cv_env_CC_value= ac_cv_env_CFLAGS_set= ac_cv_env_CFLAGS_value= ac_cv_env_CPPFLAGS_set= ac_cv_env_CPPFLAGS_value= ac_cv_env_CPP_set= ac_cv_env_CPP_value= ac_cv_env_LDFLAGS_set= ac_cv_env_LDFLAGS_value= ac_cv_env_LIBS_set= ac_cv_env_LIBS_value= ac_cv_env_build_alias_set= ac_cv_env_build_alias_value= ac_cv_env_host_alias_set= ac_cv_env_host_alias_value= ac_cv_env_target_alias_set= ac_cv_env_target_alias_value= ac_cv_func_malloc_0_nonnull=yes ac_cv_func_memset=yes ac_cv_header_inttypes_h=yes ac_cv_header_limits_h=yes ac_cv_header_memory_h=yes ac_cv_header_stdc=yes ac_cv_header_stdint_h=yes ac_cv_header_stdlib_h=yes ac_cv_header_string_h=yes ac_cv_header_strings_h=yes ac_cv_header_sys_stat_h=yes ac_cv_header_sys_types_h=yes ac_cv_header_unistd_h=yes ac_cv_lib_raptor2_raptor_parse=no ac_cv_lib_rasqal_rasqal_new_world=no ac_cv_objext=o ac_cv_path_EGREP='/usr/bin/grep -E' ac_cv_path_GREP=/usr/bin/grep ac_cv_path_install='/opt/local/bin/ginstall -c' ac_cv_path_mkdir=/opt/local/bin/gmkdir ac_cv_prog_AWK=gawk ac_cv_prog_CPP='gcc -E' ac_cv_prog_PKG_CONFIG=pkg-config ac_cv_prog_R=R ac_cv_prog_ac_ct_CC=gcc ac_cv_prog_cc_c89= ac_cv_prog_cc_g=yes ac_cv_prog_make_make_set=yes ac_cv_type_size_t=yes am_cv_CC_dependencies_compiler_type=none am_cv_make_support_nested_variables=yes am_cv_prog_cc_c_o=yes ## ----------------- ## ## Output variables. ## ## ----------------- ## ACLOCAL='${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing aclocal-1.15' AMDEPBACKSLASH='\' AMDEP_FALSE='#' AMDEP_TRUE='' AMTAR='$${TAR-tar}' AM_BACKSLASH='\' AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' AM_DEFAULT_VERBOSITY='1' AM_V='$(V)' AUTOCONF='${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing autoconf' AUTOHEADER='${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing autoheader' AUTOMAKE='${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing automake-1.15' AWK='gawk' CC='gcc' CCDEPMODE='depmode=none' CFLAGS='-g -O2' CPP='gcc -E' CPPFLAGS='' CYGPATH_W='echo' DEFS='-DPACKAGE_NAME=\"redland\" -DPACKAGE_TARNAME=\"redland\" -DPACKAGE_VERSION=\"1.0.14\" -DPACKAGE_STRING=\"redland\ 1.0.14\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DPACKAGE=\"redland\" -DVERSION=\"1.0.14\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_LIMITS_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_STDLIB_H=1 -DHAVE_MALLOC=1 -DHAVE_MEMSET=1' DEPDIR='.deps' ECHO_C='\c' ECHO_N='' ECHO_T='' EGREP='/usr/bin/grep -E' EXEEXT='' GREP='/usr/bin/grep' INSTALL_DATA='${INSTALL} -m 644' INSTALL_PROGRAM='${INSTALL}' INSTALL_SCRIPT='${INSTALL}' INSTALL_STRIP_PROGRAM='$(install_sh) -c -s' LDFLAGS='' LIBOBJS='' LIBRDF_CPPFLAGS=' -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 ' LIBRDF_LDFLAGS=' -L/opt/local/lib -lrdf ' LIBS='' LTLIBOBJS='' MAINT='#' MAINTAINER_MODE_FALSE='' MAINTAINER_MODE_TRUE='#' MAKEINFO='${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing makeinfo' MKDIR_P='/opt/local/bin/gmkdir -p' OBJEXT='o' PACKAGE='redland' PACKAGE_BUGREPORT='' PACKAGE_NAME='redland' PACKAGE_STRING='redland 1.0.14' PACKAGE_TARNAME='redland' PACKAGE_URL='' PACKAGE_VERSION='1.0.14' PATH_SEPARATOR=':' PKG_CONFIG='pkg-config' R='R' RAPTOR_LDFLAGS='-L/opt/local/lib -lraptor2 ' RASQAL_LDFLAGS='-L/opt/local/lib -lrasqal -lraptor2 ' SET_MAKE='' SHELL='/bin/sh' STRIP='' VERSION='1.0.14' ac_ct_CC='gcc' am__EXEEXT_FALSE='' am__EXEEXT_TRUE='#' am__fastdepCC_FALSE='' am__fastdepCC_TRUE='#' am__include='include' am__isrc='' am__leading_dot='.' am__nodep='_no' am__quote='' am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' bindir='${exec_prefix}/bin' build_alias='' datadir='${datarootdir}' datarootdir='${prefix}/share' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' dvidir='${docdir}' exec_prefix='${prefix}' host_alias='' htmldir='${docdir}' includedir='${prefix}/include' infodir='${datarootdir}/info' install_sh='${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/install-sh' libdir='${exec_prefix}/lib' libexecdir='${exec_prefix}/libexec' localedir='${datarootdir}/locale' localstatedir='${prefix}/var' mandir='${datarootdir}/man' mkdir_p='$(MKDIR_P)' oldincludedir='/usr/include' pdfdir='${docdir}' prefix='/usr/local' program_transform_name='s,x,x,' psdir='${docdir}' sbindir='${exec_prefix}/sbin' sharedstatedir='${prefix}/com' sysconfdir='${prefix}/etc' target_alias='' ## ----------- ## ## confdefs.h. ## ## ----------- ## /* confdefs.h */ #define PACKAGE_NAME "redland" #define PACKAGE_TARNAME "redland" #define PACKAGE_VERSION "1.0.14" #define PACKAGE_STRING "redland 1.0.14" #define PACKAGE_BUGREPORT "" #define PACKAGE_URL "" #define PACKAGE "redland" #define VERSION "1.0.14" #define STDC_HEADERS 1 #define HAVE_SYS_TYPES_H 1 #define HAVE_SYS_STAT_H 1 #define HAVE_STDLIB_H 1 #define HAVE_STRING_H 1 #define HAVE_MEMORY_H 1 #define HAVE_STRINGS_H 1 #define HAVE_INTTYPES_H 1 #define HAVE_STDINT_H 1 #define HAVE_UNISTD_H 1 #define HAVE_LIMITS_H 1 #define HAVE_STDLIB_H 1 #define HAVE_STRING_H 1 #define HAVE_STDLIB_H 1 #define HAVE_MALLOC 1 #define HAVE_MEMSET 1 configure: exit 0 redland/inst/config.status0000755000176200001440000007230012535362125015363 0ustar liggesusers#! /bin/sh # Generated by configure. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=${CONFIG_SHELL-/bin/sh} export SHELL ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by redland $as_me 1.0.14, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " # Files that config.status was made for. config_files=" Makefile" config_commands=" depfiles" ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE Configuration files: $config_files Configuration commands: $config_commands Report bugs to the package provider." ac_cs_config="" ac_cs_version="\ redland config.status 1.0.14 configured by ./configure, generated by GNU Autoconf 2.69, with options \"$ac_cs_config\" Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='/Users/jones/development/redland-bindings/R/redland/inst' srcdir='.' INSTALL='/opt/local/bin/ginstall -c' MKDIR_P='/opt/local/bin/gmkdir -p' AWK='gawk' test -n "$AWK" || AWK=awk # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --he | --h | --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi if $ac_cs_recheck; then set X /bin/sh './configure' $ac_configure_extra_args --no-create --no-recursion shift $as_echo "running CONFIG_SHELL=/bin/sh $*" >&6 CONFIG_SHELL='/bin/sh' export CONFIG_SHELL exec "$@" fi exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 # # INIT-COMMANDS # AMDEP_TRUE="" ac_aux_dir="." # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && cat >>"$ac_tmp/subs1.awk" <<\_ACAWK && S["am__EXEEXT_FALSE"]="" S["am__EXEEXT_TRUE"]="#" S["LTLIBOBJS"]="" S["RASQAL_LDFLAGS"]="-L/opt/local/lib -lrasqal -lraptor2 " S["RAPTOR_LDFLAGS"]="-L/opt/local/lib -lraptor2 " S["LIBRDF_LDFLAGS"]=" -L/opt/local/lib -lrdf " S["LIBRDF_CPPFLAGS"]=" -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 " S["LIBOBJS"]="" S["EGREP"]="/usr/bin/grep -E" S["GREP"]="/usr/bin/grep" S["CPP"]="gcc -E" S["PKG_CONFIG"]="pkg-config" S["R"]="R" S["am__fastdepCC_FALSE"]="" S["am__fastdepCC_TRUE"]="#" S["CCDEPMODE"]="depmode=none" S["am__nodep"]="_no" S["AMDEPBACKSLASH"]="\\" S["AMDEP_FALSE"]="#" S["AMDEP_TRUE"]="" S["am__quote"]="" S["am__include"]="include" S["DEPDIR"]=".deps" S["OBJEXT"]="o" S["EXEEXT"]="" S["ac_ct_CC"]="gcc" S["CPPFLAGS"]="" S["LDFLAGS"]="" S["CFLAGS"]="-g -O2" S["CC"]="gcc" S["MAINT"]="#" S["MAINTAINER_MODE_FALSE"]="" S["MAINTAINER_MODE_TRUE"]="#" S["AM_BACKSLASH"]="\\" S["AM_DEFAULT_VERBOSITY"]="1" S["AM_DEFAULT_V"]="$(AM_DEFAULT_VERBOSITY)" S["AM_V"]="$(V)" S["am__untar"]="$${TAR-tar} xf -" S["am__tar"]="$${TAR-tar} chof - \"$$tardir\"" S["AMTAR"]="$${TAR-tar}" S["am__leading_dot"]="." S["SET_MAKE"]="" S["AWK"]="gawk" S["mkdir_p"]="$(MKDIR_P)" S["MKDIR_P"]="/opt/local/bin/gmkdir -p" S["INSTALL_STRIP_PROGRAM"]="$(install_sh) -c -s" S["STRIP"]="" S["install_sh"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/install-sh" S["MAKEINFO"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing makeinfo" S["AUTOHEADER"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing autoheader" S["AUTOMAKE"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing automake-1.15" S["AUTOCONF"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing autoconf" S["ACLOCAL"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/inst/missing aclocal-1.15" S["VERSION"]="1.0.14" S["PACKAGE"]="redland" S["CYGPATH_W"]="echo" S["am__isrc"]="" S["INSTALL_DATA"]="${INSTALL} -m 644" S["INSTALL_SCRIPT"]="${INSTALL}" S["INSTALL_PROGRAM"]="${INSTALL}" S["target_alias"]="" S["host_alias"]="" S["build_alias"]="" S["LIBS"]="" S["ECHO_T"]="" S["ECHO_N"]="" S["ECHO_C"]="\\c" S["DEFS"]="-DPACKAGE_NAME=\\\"redland\\\" -DPACKAGE_TARNAME=\\\"redland\\\" -DPACKAGE_VERSION=\\\"1.0.14\\\" -DPACKAGE_STRING=\\\"redland\\ 1.0.14\\\" -DPACKAGE_BUGREPORT=\\\"\\\" "\ "-DPACKAGE_URL=\\\"\\\" -DPACKAGE=\\\"redland\\\" -DVERSION=\\\"1.0.14\\\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STR"\ "ING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_LIMITS_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRI"\ "NG_H=1 -DHAVE_STDLIB_H=1 -DHAVE_MALLOC=1 -DHAVE_MEMSET=1" S["mandir"]="${datarootdir}/man" S["localedir"]="${datarootdir}/locale" S["libdir"]="${exec_prefix}/lib" S["psdir"]="${docdir}" S["pdfdir"]="${docdir}" S["dvidir"]="${docdir}" S["htmldir"]="${docdir}" S["infodir"]="${datarootdir}/info" S["docdir"]="${datarootdir}/doc/${PACKAGE_TARNAME}" S["oldincludedir"]="/usr/include" S["includedir"]="${prefix}/include" S["localstatedir"]="${prefix}/var" S["sharedstatedir"]="${prefix}/com" S["sysconfdir"]="${prefix}/etc" S["datadir"]="${datarootdir}" S["datarootdir"]="${prefix}/share" S["libexecdir"]="${exec_prefix}/libexec" S["sbindir"]="${exec_prefix}/sbin" S["bindir"]="${exec_prefix}/bin" S["program_transform_name"]="s,x,x," S["prefix"]="/usr/local" S["exec_prefix"]="${prefix}" S["PACKAGE_URL"]="" S["PACKAGE_BUGREPORT"]="" S["PACKAGE_STRING"]="redland 1.0.14" S["PACKAGE_VERSION"]="1.0.14" S["PACKAGE_TARNAME"]="redland" S["PACKAGE_NAME"]="redland" S["PATH_SEPARATOR"]=":" S["SHELL"]="/bin/sh" _ACAWK cat >>"$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 fi # test -n "$CONFIG_FILES" eval set X " :F $CONFIG_FILES :C $CONFIG_COMMANDS" shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # case $INSTALL in [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; esac ac_MKDIR_P=$MKDIR_P case $MKDIR_P in [\\/$]* | ?:[\\/]* ) ;; */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; esac # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} ac_datarootdir_hack=' s&@datadir@&${datarootdir}&g s&@docdir@&${datarootdir}/doc/${PACKAGE_TARNAME}&g s&@infodir@&${datarootdir}/info&g s&@localedir@&${datarootdir}/locale&g s&@mandir@&${datarootdir}/man&g s&\${datarootdir}&${prefix}/share&g' ;; esac ac_sed_extra="/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// } :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t s&@MKDIR_P@&$ac_MKDIR_P&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 $as_echo "$as_me: executing $ac_file commands" >&6;} ;; esac case $ac_file$ac_mode in "depfiles":C) test x"$AMDEP_TRUE" != x"" || { # Older Autoconf quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. case $CONFIG_FILES in *\'*) eval set x "$CONFIG_FILES" ;; *) set x $CONFIG_FILES ;; esac shift for mf do # Strip MF so we end up with the name of the file. mf=`echo "$mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile or not. # We used to match only the files named 'Makefile.in', but # some people rename them; so instead we look at the file content. # Grep'ing the first line is not enough: some people post-process # each Makefile.in and add a new line on top of each file to say so. # Grep'ing the whole file is not good either: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then dirpart=`$as_dirname -- "$mf" || $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$mf" : 'X\(//\)[^/]' \| \ X"$mf" : 'X\(//\)$' \| \ X"$mf" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$mf" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` else continue fi # Extract the definition of DEPDIR, am__include, and am__quote # from the Makefile without running 'make'. DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` test -z "$DEPDIR" && continue am__include=`sed -n 's/^am__include = //p' < "$mf"` test -z "$am__include" && continue am__quote=`sed -n 's/^am__quote = //p' < "$mf"` # Find all dependency output files, they are included files with # $(DEPDIR) in their names. We invoke sed twice because it is the # simplest approach to changing $(DEPDIR) to its actual value in the # expansion. for file in `sed -n " s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do # Make sure the directory exists. test -f "$dirpart/$file" && continue fdir=`$as_dirname -- "$file" || $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$file" : 'X\(//\)[^/]' \| \ X"$file" : 'X\(//\)$' \| \ X"$file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir=$dirpart/$fdir; as_fn_mkdir_p # echo "creating $dirpart/$file" echo '# dummy' > "$dirpart/$file" done done } ;; esac done # for ac_tag as_fn_exit 0 redland/inst/NOTICE0000644000176200001440000000130314172340774013552 0ustar liggesusersThis product includes Redland software (https://librdf.org/) developed at the Institute for Learning and Research Technology, University of Bristol, UK (http://www.bristol.ac.uk/). Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. redland/inst/extdata/0000755000176200001440000000000013315102666014275 5ustar liggesusersredland/inst/extdata/dc.rdf0000755000176200001440000000061112535430316015360 0ustar liggesusers Dave Beckett's Home Page Dave Beckett The generic home page of Dave Beckett. redland/inst/extdata/example.rdf0000644000176200001440000000060612535430316016426 0ustar liggesusers John Smith's Home Page John Smith The generic home page of John Smith redland/inst/COPYRIGHTS0000644000176200001440000000210514172340774014265 0ustar liggesusersThe Redland R package is copyright; Copyright (C) 2014-2016 Regents of the University of California This product includes Redland software (https://librdf.org/) developed at the Institute for Learning and Research Technology, University of Bristol, UK (http://www.bristol.ac.uk/). Redland Software is copyright: Copyright (C) 2000-2013 David Beckett Copyright (C) 2000-2005 University of Bristol and is included in this derivative product under the terms of the Apache 2 license, which requires posting of a NOTICE file, which is included in this package. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. redland/inst/WORDLIST0000644000176200001440000000130014433104445014026 0ustar liggesusersABI Budden Cómo Destructor ExternalReferences Github Gries Hola HomeBrew Homebrew MacPorts Macports NAMSPACE NCEAS QueryResult QueryResults RDF RDF's Rasqal Roxygen Schildhauer SPARQL SWIGArray Serializer Synchronise URI URIs Uuri VM VignetteEncoding VignetteEngine VignetteIndexEntry XMLSchema api conten csv deserialized devtools doi env estás executeQuery externalptr formness freeNode func funciton getNextResult http https initialise isa json knitr lexicographically li libdf librdf mergeNamespace mergedNamespace mimeType mysql nceas nodeID normalised parsers postgresql querystring rasqal rdf rdfxml rmarkdown roc roclet roclets ropensci roxygen roxygenize roxygenized serializer ubuntu uri www redland/tools/0000755000176200001440000000000015116115726013030 5ustar liggesusersredland/tools/README0000644000176200001440000000000007033341020013661 0ustar liggesusersredland/tools/aclocal.m40000644000176200001440000012542612535431231014674 0ustar liggesusers# generated automatically by aclocal 1.15 -*- Autoconf -*- # Copyright (C) 1996-2014 Free Software Foundation, Inc. # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],, [m4_warning([this file was generated for autoconf 2.69. You have another version of autoconf. It may work, but is not guaranteed to. If you have problems, you may need to regenerate the build system entirely. To do so, use the procedure documented by the package, typically 'autoreconf'.])]) # Copyright (C) 2002-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_AUTOMAKE_VERSION(VERSION) # ---------------------------- # Automake X.Y traces this macro to ensure aclocal.m4 has been # generated from the m4 files accompanying Automake X.Y. # (This private macro should not be called outside this file.) AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version='1.15' dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to dnl require some minimum version. Point them to the right macro. m4_if([$1], [1.15], [], [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl ]) # _AM_AUTOCONF_VERSION(VERSION) # ----------------------------- # aclocal traces this macro to find the Autoconf version. # This is a private macro too. Using m4_define simplifies # the logic in aclocal, which can simply ignore this definition. m4_define([_AM_AUTOCONF_VERSION], []) # AM_SET_CURRENT_AUTOMAKE_VERSION # ------------------------------- # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced. # This function is AC_REQUIREd by AM_INIT_AUTOMAKE. AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], [AM_AUTOMAKE_VERSION([1.15])dnl m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) # AM_AUX_DIR_EXPAND -*- Autoconf -*- # Copyright (C) 2001-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets # $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to # '$srcdir', '$srcdir/..', or '$srcdir/../..'. # # Of course, Automake must honor this variable whenever it calls a # tool from the auxiliary directory. The problem is that $srcdir (and # therefore $ac_aux_dir as well) can be either absolute or relative, # depending on how configure is run. This is pretty annoying, since # it makes $ac_aux_dir quite unusable in subdirectories: in the top # source directory, any form will work fine, but in subdirectories a # relative path needs to be adjusted first. # # $ac_aux_dir/missing # fails when called from a subdirectory if $ac_aux_dir is relative # $top_srcdir/$ac_aux_dir/missing # fails if $ac_aux_dir is absolute, # fails when called from a subdirectory in a VPATH build with # a relative $ac_aux_dir # # The reason of the latter failure is that $top_srcdir and $ac_aux_dir # are both prefixed by $srcdir. In an in-source build this is usually # harmless because $srcdir is '.', but things will broke when you # start a VPATH build or use an absolute $srcdir. # # So we could use something similar to $top_srcdir/$ac_aux_dir/missing, # iff we strip the leading $srcdir from $ac_aux_dir. That would be: # am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"` # and then we would define $MISSING as # MISSING="\${SHELL} $am_aux_dir/missing" # This will work as long as MISSING is not called from configure, because # unfortunately $(top_srcdir) has no meaning in configure. # However there are other variables, like CC, which are often used in # configure, and could therefore not use this "fixed" $ac_aux_dir. # # Another solution, used here, is to always expand $ac_aux_dir to an # absolute PATH. The drawback is that using absolute paths prevent a # configured tree to be moved without reconfiguration. AC_DEFUN([AM_AUX_DIR_EXPAND], [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl # Expand $ac_aux_dir to an absolute path. am_aux_dir=`cd "$ac_aux_dir" && pwd` ]) # AM_CONDITIONAL -*- Autoconf -*- # Copyright (C) 1997-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_CONDITIONAL(NAME, SHELL-CONDITION) # ------------------------------------- # Define a conditional. AC_DEFUN([AM_CONDITIONAL], [AC_PREREQ([2.52])dnl m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl AC_SUBST([$1_TRUE])dnl AC_SUBST([$1_FALSE])dnl _AM_SUBST_NOTMAKE([$1_TRUE])dnl _AM_SUBST_NOTMAKE([$1_FALSE])dnl m4_define([_AM_COND_VALUE_$1], [$2])dnl if $2; then $1_TRUE= $1_FALSE='#' else $1_TRUE='#' $1_FALSE= fi AC_CONFIG_COMMANDS_PRE( [if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then AC_MSG_ERROR([[conditional "$1" was never defined. Usually this means the macro was only invoked conditionally.]]) fi])]) # Copyright (C) 1999-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be # written in clear, in which case automake, when reading aclocal.m4, # will think it sees a *use*, and therefore will trigger all it's # C support machinery. Also note that it means that autoscan, seeing # CC etc. in the Makefile, will ask for an AC_PROG_CC use... # _AM_DEPENDENCIES(NAME) # ---------------------- # See how the compiler implements dependency checking. # NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC". # We try a few techniques and use that to set a single cache variable. # # We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was # modified to invoke _AM_DEPENDENCIES(CC); we would have a circular # dependency, and given that the user is not expected to run this macro, # just rely on AC_PROG_CC. AC_DEFUN([_AM_DEPENDENCIES], [AC_REQUIRE([AM_SET_DEPDIR])dnl AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl AC_REQUIRE([AM_MAKE_INCLUDE])dnl AC_REQUIRE([AM_DEP_TRACK])dnl m4_if([$1], [CC], [depcc="$CC" am_compiler_list=], [$1], [CXX], [depcc="$CXX" am_compiler_list=], [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'], [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'], [$1], [UPC], [depcc="$UPC" am_compiler_list=], [$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'], [depcc="$$1" am_compiler_list=]) AC_CACHE_CHECK([dependency style of $depcc], [am_cv_$1_dependencies_compiler_type], [if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named 'D' -- because '-MD' means "put the output # in D". rm -rf conftest.dir mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_$1_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp` fi am__universal=false m4_case([$1], [CC], [case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac], [CXX], [case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac]) for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with # Solaris 10 /bin/sh. echo '/* dummy */' > sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with '-c' and '-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle '-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs. am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # After this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested. if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvc7 | msvc7msys | msvisualcpp | msvcmsys) # This compiler won't grok '-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_$1_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_$1_dependencies_compiler_type=none fi ]) AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type]) AM_CONDITIONAL([am__fastdep$1], [ test "x$enable_dependency_tracking" != xno \ && test "$am_cv_$1_dependencies_compiler_type" = gcc3]) ]) # AM_SET_DEPDIR # ------------- # Choose a directory name for dependency files. # This macro is AC_REQUIREd in _AM_DEPENDENCIES. AC_DEFUN([AM_SET_DEPDIR], [AC_REQUIRE([AM_SET_LEADING_DOT])dnl AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl ]) # AM_DEP_TRACK # ------------ AC_DEFUN([AM_DEP_TRACK], [AC_ARG_ENABLE([dependency-tracking], [dnl AS_HELP_STRING( [--enable-dependency-tracking], [do not reject slow dependency extractors]) AS_HELP_STRING( [--disable-dependency-tracking], [speeds up one-time build])]) if test "x$enable_dependency_tracking" != xno; then am_depcomp="$ac_aux_dir/depcomp" AMDEPBACKSLASH='\' am__nodep='_no' fi AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) AC_SUBST([AMDEPBACKSLASH])dnl _AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl AC_SUBST([am__nodep])dnl _AM_SUBST_NOTMAKE([am__nodep])dnl ]) # Generate code to set up dependency tracking. -*- Autoconf -*- # Copyright (C) 1999-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # _AM_OUTPUT_DEPENDENCY_COMMANDS # ------------------------------ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], [{ # Older Autoconf quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. case $CONFIG_FILES in *\'*) eval set x "$CONFIG_FILES" ;; *) set x $CONFIG_FILES ;; esac shift for mf do # Strip MF so we end up with the name of the file. mf=`echo "$mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile or not. # We used to match only the files named 'Makefile.in', but # some people rename them; so instead we look at the file content. # Grep'ing the first line is not enough: some people post-process # each Makefile.in and add a new line on top of each file to say so. # Grep'ing the whole file is not good either: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then dirpart=`AS_DIRNAME("$mf")` else continue fi # Extract the definition of DEPDIR, am__include, and am__quote # from the Makefile without running 'make'. DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` test -z "$DEPDIR" && continue am__include=`sed -n 's/^am__include = //p' < "$mf"` test -z "$am__include" && continue am__quote=`sed -n 's/^am__quote = //p' < "$mf"` # Find all dependency output files, they are included files with # $(DEPDIR) in their names. We invoke sed twice because it is the # simplest approach to changing $(DEPDIR) to its actual value in the # expansion. for file in `sed -n " s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do # Make sure the directory exists. test -f "$dirpart/$file" && continue fdir=`AS_DIRNAME(["$file"])` AS_MKDIR_P([$dirpart/$fdir]) # echo "creating $dirpart/$file" echo '# dummy' > "$dirpart/$file" done done } ])# _AM_OUTPUT_DEPENDENCY_COMMANDS # AM_OUTPUT_DEPENDENCY_COMMANDS # ----------------------------- # This macro should only be invoked once -- use via AC_REQUIRE. # # This code is only required when automatic dependency tracking # is enabled. FIXME. This creates each '.P' file that we will # need in order to bootstrap the dependency handling code. AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS], [AC_CONFIG_COMMANDS([depfiles], [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS], [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"]) ]) # Do all the work for Automake. -*- Autoconf -*- # Copyright (C) 1996-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This macro actually does too much. Some checks are only needed if # your package does certain things. But this isn't really a big deal. dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O. m4_define([AC_PROG_CC], m4_defn([AC_PROG_CC]) [_AM_PROG_CC_C_O ]) # AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE]) # AM_INIT_AUTOMAKE([OPTIONS]) # ----------------------------------------------- # The call with PACKAGE and VERSION arguments is the old style # call (pre autoconf-2.50), which is being phased out. PACKAGE # and VERSION should now be passed to AC_INIT and removed from # the call to AM_INIT_AUTOMAKE. # We support both call styles for the transition. After # the next Automake release, Autoconf can make the AC_INIT # arguments mandatory, and then we can depend on a new Autoconf # release and drop the old call support. AC_DEFUN([AM_INIT_AUTOMAKE], [AC_PREREQ([2.65])dnl dnl Autoconf wants to disallow AM_ names. We explicitly allow dnl the ones we care about. m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl AC_REQUIRE([AC_PROG_INSTALL])dnl if test "`cd $srcdir && pwd`" != "`pwd`"; then # Use -I$(srcdir) only when $(srcdir) != ., so that make's output # is not polluted with repeated "-I." AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl # test to see if srcdir already configured if test -f $srcdir/config.status; then AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) fi fi # test whether we have cygpath if test -z "$CYGPATH_W"; then if (cygpath --version) >/dev/null 2>/dev/null; then CYGPATH_W='cygpath -w' else CYGPATH_W=echo fi fi AC_SUBST([CYGPATH_W]) # Define the identity of the package. dnl Distinguish between old-style and new-style calls. m4_ifval([$2], [AC_DIAGNOSE([obsolete], [$0: two- and three-arguments forms are deprecated.]) m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl AC_SUBST([PACKAGE], [$1])dnl AC_SUBST([VERSION], [$2])], [_AM_SET_OPTIONS([$1])dnl dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT. m4_if( m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]), [ok:ok],, [m4_fatal([AC_INIT should be called with package and version arguments])])dnl AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl _AM_IF_OPTION([no-define],, [AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package]) AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl # Some tools Automake needs. AC_REQUIRE([AM_SANITY_CHECK])dnl AC_REQUIRE([AC_ARG_PROGRAM])dnl AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}]) AM_MISSING_PROG([AUTOCONF], [autoconf]) AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}]) AM_MISSING_PROG([AUTOHEADER], [autoheader]) AM_MISSING_PROG([MAKEINFO], [makeinfo]) AC_REQUIRE([AM_PROG_INSTALL_SH])dnl AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl AC_REQUIRE([AC_PROG_MKDIR_P])dnl # For better backward compatibility. To be removed once Automake 1.9.x # dies out for good. For more background, see: # # AC_SUBST([mkdir_p], ['$(MKDIR_P)']) # We need awk for the "check" target (and possibly the TAP driver). The # system "awk" is bad on some platforms. AC_REQUIRE([AC_PROG_AWK])dnl AC_REQUIRE([AC_PROG_MAKE_SET])dnl AC_REQUIRE([AM_SET_LEADING_DOT])dnl _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], [_AM_PROG_TAR([v7])])]) _AM_IF_OPTION([no-dependencies],, [AC_PROVIDE_IFELSE([AC_PROG_CC], [_AM_DEPENDENCIES([CC])], [m4_define([AC_PROG_CC], m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl AC_PROVIDE_IFELSE([AC_PROG_CXX], [_AM_DEPENDENCIES([CXX])], [m4_define([AC_PROG_CXX], m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl AC_PROVIDE_IFELSE([AC_PROG_OBJC], [_AM_DEPENDENCIES([OBJC])], [m4_define([AC_PROG_OBJC], m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], [_AM_DEPENDENCIES([OBJCXX])], [m4_define([AC_PROG_OBJCXX], m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl ]) AC_REQUIRE([AM_SILENT_RULES])dnl dnl The testsuite driver may need to know about EXEEXT, so add the dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below. AC_CONFIG_COMMANDS_PRE(dnl [m4_provide_if([_AM_COMPILER_EXEEXT], [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl # POSIX will say in a future version that running "rm -f" with no argument # is OK; and we want to be able to make that assumption in our Makefile # recipes. So use an aggressive probe to check that the usage we want is # actually supported "in the wild" to an acceptable degree. # See automake bug#10828. # To make any issue more visible, cause the running configure to be aborted # by default if the 'rm' program in use doesn't match our expectations; the # user can still override this though. if rm -f && rm -fr && rm -rf; then : OK; else cat >&2 <<'END' Oops! Your 'rm' program seems unable to run without file operands specified on the command line, even when the '-f' option is present. This is contrary to the behaviour of most rm programs out there, and not conforming with the upcoming POSIX standard: Please tell bug-automake@gnu.org about your system, including the value of your $PATH and any error possibly output before this message. This can help us improve future automake versions. END if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then echo 'Configuration will proceed anyway, since you have set the' >&2 echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 echo >&2 else cat >&2 <<'END' Aborting the configuration process, to ensure you take notice of the issue. You can download and install GNU coreutils to get an 'rm' implementation that behaves properly: . If you want to complete the configuration process using your problematic 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM to "yes", and re-run configure. END AC_MSG_ERROR([Your 'rm' program is bad, sorry.]) fi fi dnl The trailing newline in this macro's definition is deliberate, for dnl backward compatibility and to allow trailing 'dnl'-style comments dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841. ]) dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further dnl mangled by Autoconf and run in a shell conditional statement. m4_define([_AC_COMPILER_EXEEXT], m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])]) # When config.status generates a header, we must update the stamp-h file. # This file resides in the same directory as the config header # that is generated. The stamp files are numbered to have different names. # Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the # loop where config.status creates the headers, so we can generate # our stamp files there. AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], [# Compute $1's index in $config_headers. _am_arg=$1 _am_stamp_count=1 for _am_header in $config_headers :; do case $_am_header in $_am_arg | $_am_arg:* ) break ;; * ) _am_stamp_count=`expr $_am_stamp_count + 1` ;; esac done echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count]) # Copyright (C) 2001-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_PROG_INSTALL_SH # ------------------ # Define $install_sh. AC_DEFUN([AM_PROG_INSTALL_SH], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl if test x"${install_sh+set}" != xset; then case $am_aux_dir in *\ * | *\ *) install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; *) install_sh="\${SHELL} $am_aux_dir/install-sh" esac fi AC_SUBST([install_sh])]) # Copyright (C) 2003-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # Check whether the underlying file-system supports filenames # with a leading dot. For instance MS-DOS doesn't. AC_DEFUN([AM_SET_LEADING_DOT], [rm -rf .tst 2>/dev/null mkdir .tst 2>/dev/null if test -d .tst; then am__leading_dot=. else am__leading_dot=_ fi rmdir .tst 2>/dev/null AC_SUBST([am__leading_dot])]) # Add --enable-maintainer-mode option to configure. -*- Autoconf -*- # From Jim Meyering # Copyright (C) 1996-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_MAINTAINER_MODE([DEFAULT-MODE]) # ---------------------------------- # Control maintainer-specific portions of Makefiles. # Default is to disable them, unless 'enable' is passed literally. # For symmetry, 'disable' may be passed as well. Anyway, the user # can override the default with the --enable/--disable switch. AC_DEFUN([AM_MAINTAINER_MODE], [m4_case(m4_default([$1], [disable]), [enable], [m4_define([am_maintainer_other], [disable])], [disable], [m4_define([am_maintainer_other], [enable])], [m4_define([am_maintainer_other], [enable]) m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])]) AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles]) dnl maintainer-mode's default is 'disable' unless 'enable' is passed AC_ARG_ENABLE([maintainer-mode], [AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode], am_maintainer_other[ make rules and dependencies not useful (and sometimes confusing) to the casual installer])], [USE_MAINTAINER_MODE=$enableval], [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes])) AC_MSG_RESULT([$USE_MAINTAINER_MODE]) AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes]) MAINT=$MAINTAINER_MODE_TRUE AC_SUBST([MAINT])dnl ] ) # Check to see how 'make' treats includes. -*- Autoconf -*- # Copyright (C) 2001-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_MAKE_INCLUDE() # ----------------- # Check to see how make treats includes. AC_DEFUN([AM_MAKE_INCLUDE], [am_make=${MAKE-make} cat > confinc << 'END' am__doit: @echo this is the am__doit target .PHONY: am__doit END # If we don't find an include directive, just comment out the code. AC_MSG_CHECKING([for style of include used by $am_make]) am__include="#" am__quote= _am_result=none # First try GNU make style include. echo "include confinc" > confmf # Ignore all kinds of additional output from 'make'. case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=include am__quote= _am_result=GNU ;; esac # Now try BSD make style include. if test "$am__include" = "#"; then echo '.include "confinc"' > confmf case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=.include am__quote="\"" _am_result=BSD ;; esac fi AC_SUBST([am__include]) AC_SUBST([am__quote]) AC_MSG_RESULT([$_am_result]) rm -f confinc confmf ]) # Fake the existence of programs that GNU maintainers use. -*- Autoconf -*- # Copyright (C) 1997-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_MISSING_PROG(NAME, PROGRAM) # ------------------------------ AC_DEFUN([AM_MISSING_PROG], [AC_REQUIRE([AM_MISSING_HAS_RUN]) $1=${$1-"${am_missing_run}$2"} AC_SUBST($1)]) # AM_MISSING_HAS_RUN # ------------------ # Define MISSING if not defined so far and test if it is modern enough. # If it is, set am_missing_run to use it, otherwise, to nothing. AC_DEFUN([AM_MISSING_HAS_RUN], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl AC_REQUIRE_AUX_FILE([missing])dnl if test x"${MISSING+set}" != xset; then case $am_aux_dir in *\ * | *\ *) MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; *) MISSING="\${SHELL} $am_aux_dir/missing" ;; esac fi # Use eval to expand $SHELL if eval "$MISSING --is-lightweight"; then am_missing_run="$MISSING " else am_missing_run= AC_MSG_WARN(['missing' script is too old or missing]) fi ]) # Helper functions for option handling. -*- Autoconf -*- # Copyright (C) 2001-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # _AM_MANGLE_OPTION(NAME) # ----------------------- AC_DEFUN([_AM_MANGLE_OPTION], [[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) # _AM_SET_OPTION(NAME) # -------------------- # Set option NAME. Presently that only means defining a flag for this option. AC_DEFUN([_AM_SET_OPTION], [m4_define(_AM_MANGLE_OPTION([$1]), [1])]) # _AM_SET_OPTIONS(OPTIONS) # ------------------------ # OPTIONS is a space-separated list of Automake options. AC_DEFUN([_AM_SET_OPTIONS], [m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) # _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET]) # ------------------------------------------- # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. AC_DEFUN([_AM_IF_OPTION], [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) # Copyright (C) 1999-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # _AM_PROG_CC_C_O # --------------- # Like AC_PROG_CC_C_O, but changed for automake. We rewrite AC_PROG_CC # to automatically call this. AC_DEFUN([_AM_PROG_CC_C_O], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl AC_REQUIRE_AUX_FILE([compile])dnl AC_LANG_PUSH([C])dnl AC_CACHE_CHECK( [whether $CC understands -c and -o together], [am_cv_prog_cc_c_o], [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) # Make sure it works both with $CC and with simple cc. # Following AC_PROG_CC_C_O, we do the test twice because some # compilers refuse to overwrite an existing .o file with -o, # though they will create one. am_cv_prog_cc_c_o=yes for am_i in 1 2; do if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \ && test -f conftest2.$ac_objext; then : OK else am_cv_prog_cc_c_o=no break fi done rm -f core conftest* unset am_i]) if test "$am_cv_prog_cc_c_o" != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. # But if we don't then we get into trouble of one sort or another. # A longer-term fix would be to have automake use am__CC in this case, # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" CC="$am_aux_dir/compile $CC" fi AC_LANG_POP([C])]) # For backward compatibility. AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])]) # Copyright (C) 2001-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_RUN_LOG(COMMAND) # ------------------- # Run COMMAND, save the exit status in ac_status, and log it. # (This has been adapted from Autoconf's _AC_RUN_LOG macro.) AC_DEFUN([AM_RUN_LOG], [{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD (exit $ac_status); }]) # Check to make sure that the build environment is sane. -*- Autoconf -*- # Copyright (C) 1996-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_SANITY_CHECK # --------------- AC_DEFUN([AM_SANITY_CHECK], [AC_MSG_CHECKING([whether build environment is sane]) # Reject unsafe characters in $srcdir or the absolute working directory # name. Accept space and tab only in the latter. am_lf=' ' case `pwd` in *[[\\\"\#\$\&\'\`$am_lf]]*) AC_MSG_ERROR([unsafe absolute working directory name]);; esac case $srcdir in *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*) AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);; esac # Do 'set' in a subshell so we don't clobber the current shell's # arguments. Must try -L first in case configure is actually a # symlink; some systems play weird games with the mod time of symlinks # (eg FreeBSD returns the mod time of the symlink's containing # directory). if ( am_has_slept=no for am_try in 1 2; do echo "timestamp, slept: $am_has_slept" > conftest.file set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` if test "$[*]" = "X"; then # -L didn't work. set X `ls -t "$srcdir/configure" conftest.file` fi if test "$[*]" != "X $srcdir/configure conftest.file" \ && test "$[*]" != "X conftest.file $srcdir/configure"; then # If neither matched, then we have a broken ls. This can happen # if, for instance, CONFIG_SHELL is bash and it inherits a # broken ls alias from the environment. This has actually # happened. Such a system could not be considered "sane". AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken alias in your environment]) fi if test "$[2]" = conftest.file || test $am_try -eq 2; then break fi # Just in case. sleep 1 am_has_slept=yes done test "$[2]" = conftest.file ) then # Ok. : else AC_MSG_ERROR([newly created file is older than distributed files! Check your system clock]) fi AC_MSG_RESULT([yes]) # If we didn't sleep, we still need to ensure time stamps of config.status and # generated files are strictly newer. am_sleep_pid= if grep 'slept: no' conftest.file >/dev/null 2>&1; then ( sleep 1 ) & am_sleep_pid=$! fi AC_CONFIG_COMMANDS_PRE( [AC_MSG_CHECKING([that generated files are newer than configure]) if test -n "$am_sleep_pid"; then # Hide warnings about reused PIDs. wait $am_sleep_pid 2>/dev/null fi AC_MSG_RESULT([done])]) rm -f conftest.file ]) # Copyright (C) 2009-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_SILENT_RULES([DEFAULT]) # -------------------------- # Enable less verbose build rules; with the default set to DEFAULT # ("yes" being less verbose, "no" or empty being verbose). AC_DEFUN([AM_SILENT_RULES], [AC_ARG_ENABLE([silent-rules], [dnl AS_HELP_STRING( [--enable-silent-rules], [less verbose build output (undo: "make V=1")]) AS_HELP_STRING( [--disable-silent-rules], [verbose build output (undo: "make V=0")])dnl ]) case $enable_silent_rules in @%:@ ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);; esac dnl dnl A few 'make' implementations (e.g., NonStop OS and NextStep) dnl do not support nested variable expansions. dnl See automake bug#9928 and bug#10237. am_make=${MAKE-make} AC_CACHE_CHECK([whether $am_make supports nested variables], [am_cv_make_support_nested_variables], [if AS_ECHO([['TRUE=$(BAR$(V)) BAR0=false BAR1=true V=1 am__doit: @$(TRUE) .PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then am_cv_make_support_nested_variables=yes else am_cv_make_support_nested_variables=no fi]) if test $am_cv_make_support_nested_variables = yes; then dnl Using '$V' instead of '$(V)' breaks IRIX make. AM_V='$(V)' AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' else AM_V=$AM_DEFAULT_VERBOSITY AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY fi AC_SUBST([AM_V])dnl AM_SUBST_NOTMAKE([AM_V])dnl AC_SUBST([AM_DEFAULT_V])dnl AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl AC_SUBST([AM_DEFAULT_VERBOSITY])dnl AM_BACKSLASH='\' AC_SUBST([AM_BACKSLASH])dnl _AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl ]) # Copyright (C) 2001-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_PROG_INSTALL_STRIP # --------------------- # One issue with vendor 'install' (even GNU) is that you can't # specify the program used to strip binaries. This is especially # annoying in cross-compiling environments, where the build's strip # is unlikely to handle the host's binaries. # Fortunately install-sh will honor a STRIPPROG variable, so we # always use install-sh in "make install-strip", and initialize # STRIPPROG with the value of the STRIP variable (set by the user). AC_DEFUN([AM_PROG_INSTALL_STRIP], [AC_REQUIRE([AM_PROG_INSTALL_SH])dnl # Installed binaries are usually stripped using 'strip' when the user # run "make install-strip". However 'strip' might not be the right # tool to use in cross-compilation environments, therefore Automake # will honor the 'STRIP' environment variable to overrule this program. dnl Don't test for $cross_compiling = yes, because it might be 'maybe'. if test "$cross_compiling" != no; then AC_CHECK_TOOL([STRIP], [strip], :) fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" AC_SUBST([INSTALL_STRIP_PROGRAM])]) # Copyright (C) 2006-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # _AM_SUBST_NOTMAKE(VARIABLE) # --------------------------- # Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in. # This macro is traced by Automake. AC_DEFUN([_AM_SUBST_NOTMAKE]) # AM_SUBST_NOTMAKE(VARIABLE) # -------------------------- # Public sister of _AM_SUBST_NOTMAKE. AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)]) # Check how to create a tarball. -*- Autoconf -*- # Copyright (C) 2004-2014 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # _AM_PROG_TAR(FORMAT) # -------------------- # Check how to create a tarball in format FORMAT. # FORMAT should be one of 'v7', 'ustar', or 'pax'. # # Substitute a variable $(am__tar) that is a command # writing to stdout a FORMAT-tarball containing the directory # $tardir. # tardir=directory && $(am__tar) > result.tar # # Substitute a variable $(am__untar) that extract such # a tarball read from stdin. # $(am__untar) < result.tar # AC_DEFUN([_AM_PROG_TAR], [# Always define AMTAR for backward compatibility. Yes, it's still used # in the wild :-( We should find a proper way to deprecate it ... AC_SUBST([AMTAR], ['$${TAR-tar}']) # We'll loop over all known methods to create a tar archive until one works. _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' m4_if([$1], [v7], [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], [m4_case([$1], [ustar], [# The POSIX 1988 'ustar' format is defined with fixed-size fields. # There is notably a 21 bits limit for the UID and the GID. In fact, # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343 # and bug#13588). am_max_uid=2097151 # 2^21 - 1 am_max_gid=$am_max_uid # The $UID and $GID variables are not portable, so we need to resort # to the POSIX-mandated id(1) utility. Errors in the 'id' calls # below are definitely unexpected, so allow the users to see them # (that is, avoid stderr redirection). am_uid=`id -u || echo unknown` am_gid=`id -g || echo unknown` AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format]) if test $am_uid -le $am_max_uid; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) _am_tools=none fi AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format]) if test $am_gid -le $am_max_gid; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) _am_tools=none fi], [pax], [], [m4_fatal([Unknown tar format])]) AC_MSG_CHECKING([how to create a $1 tar archive]) # Go ahead even if we have the value already cached. We do so because we # need to set the values for the 'am__tar' and 'am__untar' variables. _am_tools=${am_cv_prog_tar_$1-$_am_tools} for _am_tool in $_am_tools; do case $_am_tool in gnutar) for _am_tar in tar gnutar gtar; do AM_RUN_LOG([$_am_tar --version]) && break done am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"' am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"' am__untar="$_am_tar -xf -" ;; plaintar) # Must skip GNU tar: if it does not support --format= it doesn't create # ustar tarball either. (tar --version) >/dev/null 2>&1 && continue am__tar='tar chf - "$$tardir"' am__tar_='tar chf - "$tardir"' am__untar='tar xf -' ;; pax) am__tar='pax -L -x $1 -w "$$tardir"' am__tar_='pax -L -x $1 -w "$tardir"' am__untar='pax -r' ;; cpio) am__tar='find "$$tardir" -print | cpio -o -H $1 -L' am__tar_='find "$tardir" -print | cpio -o -H $1 -L' am__untar='cpio -i -H $1 -d' ;; none) am__tar=false am__tar_=false am__untar=false ;; esac # If the value was cached, stop now. We just wanted to have am__tar # and am__untar set. test -n "${am_cv_prog_tar_$1}" && break # tar/untar a dummy directory, and stop if the command works. rm -rf conftest.dir mkdir conftest.dir echo GrepMe > conftest.dir/file AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) rm -rf conftest.dir if test -s conftest.tar; then AM_RUN_LOG([$am__untar /dev/null 2>&1 && break fi done rm -rf conftest.dir AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool]) AC_MSG_RESULT([$am_cv_prog_tar_$1])]) AC_SUBST([am__tar]) AC_SUBST([am__untar]) ]) # _AM_PROG_TAR redland/tools/Makefile0000644000176200001440000004720515116115727014501 0ustar liggesusers# Makefile.in generated by automake 1.15 from Makefile.am. # Makefile. Generated from Makefile.in by configure. # Copyright (C) 1994-2014 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. # -*- Mode: Makefile -*- # # Makefile.am - automake file for R interface to Redland # # Copyright (C) 2014 Matthew Jones # Derived from code that was originally copyrighted: # Copyright (C) 2010 David Beckett - http://www.dajobe.org/ # And used under the terms of the Apache V2.0 license. # # This package is Free Software and part of Redland http://librdf.org/ # # It is licensed under the following three licenses as alternatives: # 1. GNU Lesser General Public License (LGPL) V2.1 or any newer version # 2. GNU General Public License (GPL) V2 or any newer version # 3. Apache License, V2.0 or any newer version # # You may not use this file except in compliance with at least one of # the above three licenses. # # See LICENSE.html or LICENSE.txt at the top of this package for the # full license terms. # am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } am__make_running_with_option = \ case $${target_option-} in \ ?) ;; \ *) echo "am__make_running_with_option: internal error: invalid" \ "target option '$${target_option-}' specified" >&2; \ exit 1;; \ esac; \ has_opt=no; \ sane_makeflags=$$MAKEFLAGS; \ if $(am__is_gnu_make); then \ sane_makeflags=$$MFLAGS; \ else \ case $$MAKEFLAGS in \ *\\[\ \ ]*) \ bs=\\; \ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ esac; \ fi; \ skip_next=no; \ strip_trailopt () \ { \ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ }; \ for flg in $$sane_makeflags; do \ test $$skip_next = yes && { skip_next=no; continue; }; \ case $$flg in \ *=*|--*) continue;; \ -*I) strip_trailopt 'I'; skip_next=yes;; \ -*I?*) strip_trailopt 'I';; \ -*O) strip_trailopt 'O'; skip_next=yes;; \ -*O?*) strip_trailopt 'O';; \ -*l) strip_trailopt 'l'; skip_next=yes;; \ -*l?*) strip_trailopt 'l';; \ -[dEDm]) skip_next=yes;; \ -[JT]) skip_next=yes;; \ esac; \ case $$flg in \ *$$target_option*) has_opt=yes; break;; \ esac; \ done; \ test $$has_opt = yes am__make_dryrun = (target_option=n; $(am__make_running_with_option)) am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) pkgdatadir = $(datadir)/redland pkgincludedir = $(includedir)/redland pkglibdir = $(libdir)/redland pkglibexecdir = $(libexecdir)/redland am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : subdir = . ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \ $(am__configure_deps) $(am__DIST_COMMON) am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = AM_V_P = $(am__v_P_$(V)) am__v_P_ = $(am__v_P_$(AM_DEFAULT_VERBOSITY)) am__v_P_0 = false am__v_P_1 = : AM_V_GEN = $(am__v_GEN_$(V)) am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) am__v_GEN_0 = @echo " GEN " $@; am__v_GEN_1 = AM_V_at = $(am__v_at_$(V)) am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY)) am__v_at_0 = @ am__v_at_1 = SOURCES = DIST_SOURCES = am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ *) (install-info --version) >/dev/null 2>&1;; \ esac am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) am__DIST_COMMON = $(srcdir)/Makefile.in COPYING INSTALL NEWS README \ compile install-sh ltmain.sh missing DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) am__remove_distdir = \ if test -d "$(distdir)"; then \ find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ && rm -rf "$(distdir)" \ || { sleep 5 && rm -rf "$(distdir)"; }; \ else :; fi am__post_remove_distdir = $(am__remove_distdir) DIST_ARCHIVES = $(distdir).tar.gz GZIP_ENV = --best DIST_TARGETS = dist-gzip distuninstallcheck_listfiles = find . -type f -print am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' distcleancheck_listfiles = find . -type f -print ACLOCAL = ${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing aclocal-1.15 AMTAR = $${TAR-tar} AM_DEFAULT_VERBOSITY = 1 AUTOCONF = ${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing autoconf AUTOHEADER = ${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing autoheader AUTOMAKE = ${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing automake-1.15 AWK = gawk CC = gcc CCDEPMODE = depmode=none CFLAGS = -g -O2 CPP = gcc -E CPPFLAGS = CYGPATH_W = echo DEFS = -DPACKAGE_NAME=\"redland\" -DPACKAGE_TARNAME=\"redland\" -DPACKAGE_VERSION=\"1.0.14\" -DPACKAGE_STRING=\"redland\ 1.0.14\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DPACKAGE=\"redland\" -DVERSION=\"1.0.14\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_LIMITS_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_STDLIB_H=1 -DHAVE_MALLOC=1 -DHAVE_MEMSET=1 DEPDIR = .deps ECHO_C = \c ECHO_N = ECHO_T = EGREP = /usr/bin/grep -E EXEEXT = GREP = /usr/bin/grep INSTALL = /opt/local/bin/ginstall -c INSTALL_DATA = ${INSTALL} -m 644 INSTALL_PROGRAM = ${INSTALL} INSTALL_SCRIPT = ${INSTALL} INSTALL_STRIP_PROGRAM = $(install_sh) -c -s LDFLAGS = LIBOBJS = LIBRDF_CPPFLAGS = -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 LIBRDF_LDFLAGS = -L/opt/local/lib -lrdf LIBS = $(SRCDIR)/redland.so LTLIBOBJS = MAINT = # MAKEINFO = ${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing makeinfo MKDIR_P = /opt/local/bin/gmkdir -p OBJEXT = o PACKAGE = redland PACKAGE_BUGREPORT = PACKAGE_NAME = redland PACKAGE_STRING = redland 1.0.14 PACKAGE_TARNAME = redland PACKAGE_URL = PACKAGE_VERSION = 1.0.14 PATH_SEPARATOR = : PKG_CONFIG = pkg-config R = R RAPTOR_LDFLAGS = -L/opt/local/lib -lraptor2 RASQAL_LDFLAGS = -L/opt/local/lib -lrasqal -lraptor2 SET_MAKE = SHELL = /bin/sh STRIP = VERSION = 1.0.14 abs_builddir = /Users/jones/development/redland-bindings/R/redland/tools abs_srcdir = /Users/jones/development/redland-bindings/R/redland/tools abs_top_builddir = /Users/jones/development/redland-bindings/R/redland/tools abs_top_srcdir = /Users/jones/development/redland-bindings/R/redland/tools ac_ct_CC = gcc am__include = include am__leading_dot = . am__quote = am__tar = $${TAR-tar} chof - "$$tardir" am__untar = $${TAR-tar} xf - bindir = ${exec_prefix}/bin build_alias = builddir = . datadir = ${datarootdir} datarootdir = ${prefix}/share docdir = ${datarootdir}/doc/${PACKAGE_TARNAME} dvidir = ${docdir} exec_prefix = ${prefix} host_alias = htmldir = ${docdir} includedir = ${prefix}/include infodir = ${datarootdir}/info install_sh = ${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/install-sh libdir = ${exec_prefix}/lib libexecdir = ${exec_prefix}/libexec localedir = ${datarootdir}/locale localstatedir = ${prefix}/var mandir = ${datarootdir}/man mkdir_p = $(MKDIR_P) oldincludedir = /usr/include pdfdir = ${docdir} prefix = /usr/local program_transform_name = s,x,x, psdir = ${docdir} sbindir = ${exec_prefix}/sbin sharedstatedir = ${prefix}/com srcdir = . sysconfdir = ${prefix}/etc target_alias = top_build_prefix = top_builddir = . top_srcdir = . SRCDIR = ../src SRCS = $(SRCDIR)/redland.c $(SRCDIR)/util.c MAKEVARS = $(SRCDIR)/Makevars CLEAN_FILES = aclocal.m4 \ autoscan.log \ config.h \ ../src/redland.o \ stamp-h1 \ ../src/util.o \ autom4te.cache \ config.h.in \ config.log \ Makefile \ ltmain.sh \ config.status all: all-am .SUFFIXES: am--refresh: Makefile @: $(srcdir)/Makefile.in: # $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \ $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \ && exit 0; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ echo ' $(SHELL) ./config.status'; \ $(SHELL) ./config.status;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) $(SHELL) ./config.status --recheck $(top_srcdir)/configure: # $(am__configure_deps) $(am__cd) $(srcdir) && $(AUTOCONF) $(ACLOCAL_M4): # $(am__aclocal_m4_deps) $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) $(am__aclocal_m4_deps): tags TAGS: ctags CTAGS: cscope cscopelist: distdir: $(DISTFILES) $(am__remove_distdir) test -d "$(distdir)" || mkdir "$(distdir)" @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ dist_files=`for file in $$list; do echo $$file; done | \ sed -e "s|^$$srcdirstrip/||;t" \ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ case $$dist_files in \ */*) $(MKDIR_P) `echo "$$dist_files" | \ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ sort -u` ;; \ esac; \ for file in $$dist_files; do \ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ if test -d $$d/$$file; then \ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ if test -d "$(distdir)/$$file"; then \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ fi; \ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ else \ test -f "$(distdir)/$$file" \ || cp -p $$d/$$file "$(distdir)/$$file" \ || exit 1; \ fi; \ done -test -n "$(am__skip_mode_fix)" \ || find "$(distdir)" -type d ! -perm -755 \ -exec chmod u+rwx,go+rx {} \; -o \ ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ || chmod -R a+r "$(distdir)" dist-gzip: distdir tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz $(am__post_remove_distdir) dist-bzip2: distdir tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 $(am__post_remove_distdir) dist-lzip: distdir tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz $(am__post_remove_distdir) dist-xz: distdir tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz $(am__post_remove_distdir) dist-tarZ: distdir @echo WARNING: "Support for distribution archives compressed with" \ "legacy program 'compress' is deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z $(am__post_remove_distdir) dist-shar: distdir @echo WARNING: "Support for shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz $(am__post_remove_distdir) dist-zip: distdir -rm -f $(distdir).zip zip -rq $(distdir).zip $(distdir) $(am__post_remove_distdir) dist dist-all: $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' $(am__post_remove_distdir) # This target untars the dist file and tries a VPATH configuration. Then # it guarantees that the distribution is self-contained by making another # tarfile. distcheck: dist case '$(DIST_ARCHIVES)' in \ *.tar.gz*) \ GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ *.tar.bz2*) \ bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ *.tar.lz*) \ lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ *.tar.xz*) \ xz -dc $(distdir).tar.xz | $(am__untar) ;;\ *.tar.Z*) \ uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ *.shar.gz*) \ GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\ *.zip*) \ unzip $(distdir).zip ;;\ esac chmod -R a-w $(distdir) chmod u+w $(distdir) mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst chmod a-w $(distdir) test -d $(distdir)/_build || exit 0; \ dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ && am__cwd=`pwd` \ && $(am__cd) $(distdir)/_build/sub \ && ../../configure \ $(AM_DISTCHECK_CONFIGURE_FLAGS) \ $(DISTCHECK_CONFIGURE_FLAGS) \ --srcdir=../.. --prefix="$$dc_install_base" \ && $(MAKE) $(AM_MAKEFLAGS) \ && $(MAKE) $(AM_MAKEFLAGS) dvi \ && $(MAKE) $(AM_MAKEFLAGS) check \ && $(MAKE) $(AM_MAKEFLAGS) install \ && $(MAKE) $(AM_MAKEFLAGS) installcheck \ && $(MAKE) $(AM_MAKEFLAGS) uninstall \ && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ distuninstallcheck \ && chmod -R a-w "$$dc_install_base" \ && ({ \ (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ } || { rm -rf "$$dc_destdir"; exit 1; }) \ && rm -rf "$$dc_destdir" \ && $(MAKE) $(AM_MAKEFLAGS) dist \ && rm -rf $(DIST_ARCHIVES) \ && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ && cd "$$am__cwd" \ || exit 1 $(am__post_remove_distdir) @(echo "$(distdir) archives ready for distribution: "; \ list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' distuninstallcheck: @test -n '$(distuninstallcheck_dir)' || { \ echo 'ERROR: trying to run $@ with an empty' \ '$$(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ $(am__cd) '$(distuninstallcheck_dir)' || { \ echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ exit 1; \ }; \ test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left after uninstall:" ; \ if test -n "$(DESTDIR)"; then \ echo " (check DESTDIR support)"; \ fi ; \ $(distuninstallcheck_listfiles) ; \ exit 1; } >&2 distcleancheck: distclean @if test '$(srcdir)' = . ; then \ echo "ERROR: distcleancheck can only run from a VPATH build" ; \ exit 1 ; \ fi @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ || { echo "ERROR: files left in build directory after distclean:" ; \ $(distcleancheck_listfiles) ; \ exit 1; } >&2 check-am: all-am check: check-am all-am: Makefile installdirs: install: install-am install-exec: install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: if test -z '$(STRIP)'; then \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ install; \ else \ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ fi mostlyclean-generic: clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." clean: clean-am clean-am: clean-generic mostlyclean-am distclean: distclean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -f Makefile distclean-am: clean-am distclean-generic dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-dvi: install-dvi-am install-dvi-am: install-exec-am: install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-generic pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: .MAKE: install-am install-strip .PHONY: all all-am am--refresh check check-am clean clean-generic \ cscopelist-am ctags-am dist dist-all dist-bzip2 dist-gzip \ dist-lzip dist-shar dist-tarZ dist-xz dist-zip distcheck \ distclean distclean-generic distcleancheck distdir \ distuninstallcheck dvi dvi-am html html-am info info-am \ install install-am install-data install-data-am install-dvi \ install-dvi-am install-exec install-exec-am install-html \ install-html-am install-info install-info-am install-man \ install-pdf install-pdf-am install-ps install-ps-am \ install-strip installcheck installcheck-am installdirs \ maintainer-clean maintainer-clean-generic mostlyclean \ mostlyclean-generic pdf pdf-am ps ps-am tags-am uninstall \ uninstall-am .PRECIOUS: Makefile $(LIBS): $(SRCS) -echo "PKG_CFLAGS = -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 " > $(MAKEVARS) -echo "PKG_LIBS = -L/opt/local/lib -lrdf -L/opt/local/lib -lrasqal -lraptor2 " >> $(MAKEVARS) cd $(SRCDIR) && R CMD SHLIB redland.c util.c #$(MAKEVARS): # -echo "PKG_CFLAGS = -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 " > $@ # -echo "PKG_LIBS = -L/opt/local/lib -lrdf -L/opt/local/lib -lrasqal -lraptor2 " >> $@ all: ${LIBS} dev-clean: rm -f $(MAKEVARS) ; \ rm -f $(LIBS) ; \ for fname in $(CLEAN_FILES); do \ if [ -d "$$fname" ]; then \ rm -f $$fname/* ; \ rmdir $$fname ; \ else \ if [ -e "$$fname" ]; then rm -f $$fname ; fi \ fi \ done; # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: redland/tools/config.log0000644000176200001440000004536712643553533015023 0ustar liggesusersThis file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by redland configure 1.0.14, which was generated by GNU Autoconf 2.69. Invocation command line was $ ./configure ## --------- ## ## Platform. ## ## --------- ## hostname = frost.local uname -m = x86_64 uname -r = 14.3.0 uname -s = Darwin uname -v = Darwin Kernel Version 14.3.0: Mon Mar 23 11:59:05 PDT 2015; root:xnu-2782.20.48~5/RELEASE_X86_64 /usr/bin/uname -p = i386 /bin/uname -X = unknown /bin/arch = unknown /usr/bin/arch -k = unknown /usr/convex/getsysinfo = unknown /usr/bin/hostinfo = Mach kernel version: Darwin Kernel Version 14.3.0: Mon Mar 23 11:59:05 PDT 2015; root:xnu-2782.20.48~5/RELEASE_X86_64 Kernel configured for up to 8 processors. 4 processors are physically available. 8 processors are logically available. Processor type: x86_64h (Intel x86-64h Haswell) Processors active: 0 1 2 3 4 5 6 7 Primary memory available: 16.00 gigabytes Default processor set: 403 tasks, 2013 threads, 8 processors Load average: 2.73, Mach factor: 5.26 /bin/machine = unknown /usr/bin/oslevel = unknown /bin/universe = unknown PATH: /opt/local/bin PATH: /opt/local/sbin PATH: /Users/jones/.rvm/gems/ruby-2.1.1/bin PATH: /Users/jones/.rvm/gems/ruby-2.1.1@global/bin PATH: /Users/jones/.rvm/rubies/ruby-2.1.1/bin PATH: /Library/Java/JavaVirtualMachines/jdk1.7.0_60.jdk/Contents/Home/bin PATH: /Library/Anaconda/bin PATH: /usr/local/bin PATH: /usr/bin PATH: /bin PATH: /usr/sbin PATH: /sbin PATH: /opt/X11/bin PATH: /Library/anaconda/bin PATH: /usr/local/sbin PATH: /opt/local/bin PATH: /opt/local/sbin PATH: /opt/local/lib/postgresql84/bin/ PATH: /Users/jones/development/dataone/allsoftware/tools/docutils PATH: /usr/texbin PATH: /Users/jones/.rvm/bin ## ----------- ## ## Core tests. ## ## ----------- ## configure:2252: checking for a BSD-compatible install configure:2320: result: /opt/local/bin/ginstall -c configure:2331: checking whether build environment is sane configure:2386: result: yes configure:2537: checking for a thread-safe mkdir -p configure:2576: result: /opt/local/bin/gmkdir -p configure:2583: checking for gawk configure:2599: found /opt/local/bin/gawk configure:2610: result: gawk configure:2621: checking whether make sets $(MAKE) configure:2643: result: yes configure:2672: checking whether make supports nested variables configure:2689: result: yes configure:2817: checking whether to enable maintainer-specific portions of Makefiles configure:2826: result: no configure:2892: checking for gcc configure:2908: found /usr/bin/gcc configure:2919: result: gcc configure:3148: checking for C compiler version configure:3157: gcc --version >&5 Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn) Target: x86_64-apple-darwin14.3.0 Thread model: posix Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1 configure:3168: $? = 0 configure:3157: gcc -v >&5 Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1 Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn) Target: x86_64-apple-darwin14.3.0 Thread model: posix configure:3168: $? = 0 configure:3157: gcc -V >&5 clang: error: argument to '-V' is missing (expected 1 value) clang: error: no input files configure:3168: $? = 1 configure:3157: gcc -qversion >&5 clang: error: unknown argument: '-qversion' clang: error: no input files configure:3168: $? = 1 configure:3188: checking whether the C compiler works configure:3210: gcc conftest.c >&5 configure:3214: $? = 0 configure:3262: result: yes configure:3265: checking for C compiler default output file name configure:3267: result: a.out configure:3273: checking for suffix of executables configure:3280: gcc -o conftest conftest.c >&5 configure:3284: $? = 0 configure:3306: result: configure:3328: checking whether we are cross compiling configure:3336: gcc -o conftest conftest.c >&5 configure:3340: $? = 0 configure:3347: ./conftest configure:3351: $? = 0 configure:3366: result: no configure:3371: checking for suffix of object files configure:3393: gcc -c conftest.c >&5 configure:3397: $? = 0 configure:3418: result: o configure:3422: checking whether we are using the GNU C compiler configure:3441: gcc -c conftest.c >&5 configure:3441: $? = 0 configure:3450: result: yes configure:3459: checking whether gcc accepts -g configure:3479: gcc -c -g conftest.c >&5 configure:3479: $? = 0 configure:3520: result: yes configure:3537: checking for gcc option to accept ISO C89 configure:3600: gcc -c -g -O2 conftest.c >&5 configure:3600: $? = 0 configure:3613: result: none needed configure:3638: checking whether gcc understands -c and -o together configure:3660: gcc -c conftest.c -o conftest2.o configure:3663: $? = 0 configure:3660: gcc -c conftest.c -o conftest2.o configure:3663: $? = 0 configure:3675: result: yes configure:3703: checking for style of include used by make configure:3731: result: GNU configure:3757: checking dependency style of gcc configure:3868: result: none configure:3888: checking for R configure:3904: found /usr/bin/R configure:3915: result: R configure:3930: checking for pkg-config configure:3946: found /opt/local/bin/pkg-config configure:3957: result: pkg-config configure:3970: checking for redland configure:3977: result: 1.0.15 configure:3993: checking for raptor_parse in -lraptor2 configure:4018: gcc -o conftest -g -O2 conftest.c -lraptor2 >&5 ld: library not found for -lraptor2 clang: error: linker command failed with exit code 1 (use -v to see invocation) configure:4018: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | /* end confdefs.h. */ | | /* Override any GCC internal prototype to avoid an error. | Use char because int might match the return type of a GCC | builtin and then its argument prototype would still apply. */ | #ifdef __cplusplus | extern "C" | #endif | char raptor_parse (); | int | main () | { | return raptor_parse (); | ; | return 0; | } configure:4027: result: no configure:4038: checking for rasqal_new_world in -lrasqal configure:4063: gcc -o conftest -g -O2 conftest.c -lrasqal >&5 ld: library not found for -lrasqal clang: error: linker command failed with exit code 1 (use -v to see invocation) configure:4063: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | /* end confdefs.h. */ | | /* Override any GCC internal prototype to avoid an error. | Use char because int might match the return type of a GCC | builtin and then its argument prototype would still apply. */ | #ifdef __cplusplus | extern "C" | #endif | char rasqal_new_world (); | int | main () | { | return rasqal_new_world (); | ; | return 0; | } configure:4072: result: no configure:4090: checking how to run the C preprocessor configure:4121: gcc -E conftest.c configure:4121: $? = 0 configure:4135: gcc -E conftest.c conftest.c:11:10: fatal error: 'ac_nonexistent.h' file not found #include ^ 1 error generated. configure:4135: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | /* end confdefs.h. */ | #include configure:4160: result: gcc -E configure:4180: gcc -E conftest.c configure:4180: $? = 0 configure:4194: gcc -E conftest.c conftest.c:11:10: fatal error: 'ac_nonexistent.h' file not found #include ^ 1 error generated. configure:4194: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | /* end confdefs.h. */ | #include configure:4223: checking for grep that handles long lines and -e configure:4281: result: /usr/bin/grep configure:4286: checking for egrep configure:4348: result: /usr/bin/grep -E configure:4353: checking for ANSI C header files configure:4373: gcc -c -g -O2 conftest.c >&5 configure:4373: $? = 0 configure:4446: gcc -o conftest -g -O2 conftest.c >&5 configure:4446: $? = 0 configure:4446: ./conftest configure:4446: $? = 0 configure:4457: result: yes configure:4470: checking for sys/types.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for sys/stat.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for stdlib.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for string.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for memory.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for strings.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for inttypes.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for stdint.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4470: checking for unistd.h configure:4470: gcc -c -g -O2 conftest.c >&5 configure:4470: $? = 0 configure:4470: result: yes configure:4485: checking limits.h usability configure:4485: gcc -c -g -O2 conftest.c >&5 configure:4485: $? = 0 configure:4485: result: yes configure:4485: checking limits.h presence configure:4485: gcc -E conftest.c configure:4485: $? = 0 configure:4485: result: yes configure:4485: checking for limits.h configure:4485: result: yes configure:4485: checking for stdlib.h configure:4485: result: yes configure:4485: checking for string.h configure:4485: result: yes configure:4497: checking for size_t configure:4497: gcc -c -g -O2 conftest.c >&5 configure:4497: $? = 0 configure:4497: gcc -c -g -O2 conftest.c >&5 conftest.c:60:21: error: expected expression if (sizeof ((size_t))) ^ 1 error generated. configure:4497: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "redland" | #define PACKAGE_TARNAME "redland" | #define PACKAGE_VERSION "1.0.14" | #define PACKAGE_STRING "redland 1.0.14" | #define PACKAGE_BUGREPORT "" | #define PACKAGE_URL "" | #define PACKAGE "redland" | #define VERSION "1.0.14" | #define STDC_HEADERS 1 | #define HAVE_SYS_TYPES_H 1 | #define HAVE_SYS_STAT_H 1 | #define HAVE_STDLIB_H 1 | #define HAVE_STRING_H 1 | #define HAVE_MEMORY_H 1 | #define HAVE_STRINGS_H 1 | #define HAVE_INTTYPES_H 1 | #define HAVE_STDINT_H 1 | #define HAVE_UNISTD_H 1 | #define HAVE_LIMITS_H 1 | #define HAVE_STDLIB_H 1 | #define HAVE_STRING_H 1 | /* end confdefs.h. */ | #include | #ifdef HAVE_SYS_TYPES_H | # include | #endif | #ifdef HAVE_SYS_STAT_H | # include | #endif | #ifdef STDC_HEADERS | # include | # include | #else | # ifdef HAVE_STDLIB_H | # include | # endif | #endif | #ifdef HAVE_STRING_H | # if !defined STDC_HEADERS && defined HAVE_MEMORY_H | # include | # endif | # include | #endif | #ifdef HAVE_STRINGS_H | # include | #endif | #ifdef HAVE_INTTYPES_H | # include | #endif | #ifdef HAVE_STDINT_H | # include | #endif | #ifdef HAVE_UNISTD_H | # include | #endif | int | main () | { | if (sizeof ((size_t))) | return 0; | ; | return 0; | } configure:4497: result: yes configure:4512: checking for stdlib.h configure:4512: result: yes configure:4522: checking for GNU libc compatible malloc configure:4546: gcc -o conftest -g -O2 conftest.c >&5 configure:4546: $? = 0 configure:4546: ./conftest configure:4546: $? = 0 configure:4556: result: yes configure:4579: checking for memset configure:4579: gcc -o conftest -g -O2 conftest.c >&5 conftest.c:49:6: warning: incompatible redeclaration of library function 'memset' [-Wincompatible-library-redeclaration] char memset (); ^ conftest.c:49:6: note: 'memset' is a builtin with type 'void *(void *, int, unsigned long)' 1 warning generated. configure:4579: $? = 0 configure:4579: result: yes configure:4749: checking that generated files are newer than configure configure:4755: result: done configure:4782: creating ./config.status ## ---------------------- ## ## Running config.status. ## ## ---------------------- ## This file was extended by redland config.status 1.0.14, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = CONFIG_HEADERS = CONFIG_LINKS = CONFIG_COMMANDS = $ ./config.status on frost.local config.status:786: creating Makefile config.status:958: executing depfiles commands ## ---------------- ## ## Cache variables. ## ## ---------------- ## ac_cv_c_compiler_gnu=yes ac_cv_env_CC_set= ac_cv_env_CC_value= ac_cv_env_CFLAGS_set= ac_cv_env_CFLAGS_value= ac_cv_env_CPPFLAGS_set= ac_cv_env_CPPFLAGS_value= ac_cv_env_CPP_set= ac_cv_env_CPP_value= ac_cv_env_LDFLAGS_set= ac_cv_env_LDFLAGS_value= ac_cv_env_LIBS_set= ac_cv_env_LIBS_value= ac_cv_env_build_alias_set= ac_cv_env_build_alias_value= ac_cv_env_host_alias_set= ac_cv_env_host_alias_value= ac_cv_env_target_alias_set= ac_cv_env_target_alias_value= ac_cv_func_malloc_0_nonnull=yes ac_cv_func_memset=yes ac_cv_header_inttypes_h=yes ac_cv_header_limits_h=yes ac_cv_header_memory_h=yes ac_cv_header_stdc=yes ac_cv_header_stdint_h=yes ac_cv_header_stdlib_h=yes ac_cv_header_string_h=yes ac_cv_header_strings_h=yes ac_cv_header_sys_stat_h=yes ac_cv_header_sys_types_h=yes ac_cv_header_unistd_h=yes ac_cv_lib_raptor2_raptor_parse=no ac_cv_lib_rasqal_rasqal_new_world=no ac_cv_objext=o ac_cv_path_EGREP='/usr/bin/grep -E' ac_cv_path_GREP=/usr/bin/grep ac_cv_path_install='/opt/local/bin/ginstall -c' ac_cv_path_mkdir=/opt/local/bin/gmkdir ac_cv_prog_AWK=gawk ac_cv_prog_CPP='gcc -E' ac_cv_prog_PKG_CONFIG=pkg-config ac_cv_prog_R=R ac_cv_prog_ac_ct_CC=gcc ac_cv_prog_cc_c89= ac_cv_prog_cc_g=yes ac_cv_prog_make_make_set=yes ac_cv_type_size_t=yes am_cv_CC_dependencies_compiler_type=none am_cv_make_support_nested_variables=yes am_cv_prog_cc_c_o=yes ## ----------------- ## ## Output variables. ## ## ----------------- ## ACLOCAL='${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing aclocal-1.15' AMDEPBACKSLASH='\' AMDEP_FALSE='#' AMDEP_TRUE='' AMTAR='$${TAR-tar}' AM_BACKSLASH='\' AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' AM_DEFAULT_VERBOSITY='1' AM_V='$(V)' AUTOCONF='${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing autoconf' AUTOHEADER='${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing autoheader' AUTOMAKE='${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing automake-1.15' AWK='gawk' CC='gcc' CCDEPMODE='depmode=none' CFLAGS='-g -O2' CPP='gcc -E' CPPFLAGS='' CYGPATH_W='echo' DEFS='-DPACKAGE_NAME=\"redland\" -DPACKAGE_TARNAME=\"redland\" -DPACKAGE_VERSION=\"1.0.14\" -DPACKAGE_STRING=\"redland\ 1.0.14\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DPACKAGE=\"redland\" -DVERSION=\"1.0.14\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_LIMITS_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_STDLIB_H=1 -DHAVE_MALLOC=1 -DHAVE_MEMSET=1' DEPDIR='.deps' ECHO_C='\c' ECHO_N='' ECHO_T='' EGREP='/usr/bin/grep -E' EXEEXT='' GREP='/usr/bin/grep' INSTALL_DATA='${INSTALL} -m 644' INSTALL_PROGRAM='${INSTALL}' INSTALL_SCRIPT='${INSTALL}' INSTALL_STRIP_PROGRAM='$(install_sh) -c -s' LDFLAGS='' LIBOBJS='' LIBRDF_CPPFLAGS=' -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 ' LIBRDF_LDFLAGS=' -L/opt/local/lib -lrdf ' LIBS='' LTLIBOBJS='' MAINT='#' MAINTAINER_MODE_FALSE='' MAINTAINER_MODE_TRUE='#' MAKEINFO='${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing makeinfo' MKDIR_P='/opt/local/bin/gmkdir -p' OBJEXT='o' PACKAGE='redland' PACKAGE_BUGREPORT='' PACKAGE_NAME='redland' PACKAGE_STRING='redland 1.0.14' PACKAGE_TARNAME='redland' PACKAGE_URL='' PACKAGE_VERSION='1.0.14' PATH_SEPARATOR=':' PKG_CONFIG='pkg-config' R='R' RAPTOR_LDFLAGS='-L/opt/local/lib -lraptor2 ' RASQAL_LDFLAGS='-L/opt/local/lib -lrasqal -lraptor2 ' SET_MAKE='' SHELL='/bin/sh' STRIP='' VERSION='1.0.14' ac_ct_CC='gcc' am__EXEEXT_FALSE='' am__EXEEXT_TRUE='#' am__fastdepCC_FALSE='' am__fastdepCC_TRUE='#' am__include='include' am__isrc='' am__leading_dot='.' am__nodep='_no' am__quote='' am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' bindir='${exec_prefix}/bin' build_alias='' datadir='${datarootdir}' datarootdir='${prefix}/share' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' dvidir='${docdir}' exec_prefix='${prefix}' host_alias='' htmldir='${docdir}' includedir='${prefix}/include' infodir='${datarootdir}/info' install_sh='${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/install-sh' libdir='${exec_prefix}/lib' libexecdir='${exec_prefix}/libexec' localedir='${datarootdir}/locale' localstatedir='${prefix}/var' mandir='${datarootdir}/man' mkdir_p='$(MKDIR_P)' oldincludedir='/usr/include' pdfdir='${docdir}' prefix='/usr/local' program_transform_name='s,x,x,' psdir='${docdir}' sbindir='${exec_prefix}/sbin' sharedstatedir='${prefix}/com' sysconfdir='${prefix}/etc' target_alias='' ## ----------- ## ## confdefs.h. ## ## ----------- ## /* confdefs.h */ #define PACKAGE_NAME "redland" #define PACKAGE_TARNAME "redland" #define PACKAGE_VERSION "1.0.14" #define PACKAGE_STRING "redland 1.0.14" #define PACKAGE_BUGREPORT "" #define PACKAGE_URL "" #define PACKAGE "redland" #define VERSION "1.0.14" #define STDC_HEADERS 1 #define HAVE_SYS_TYPES_H 1 #define HAVE_SYS_STAT_H 1 #define HAVE_STDLIB_H 1 #define HAVE_STRING_H 1 #define HAVE_MEMORY_H 1 #define HAVE_STRINGS_H 1 #define HAVE_INTTYPES_H 1 #define HAVE_STDINT_H 1 #define HAVE_UNISTD_H 1 #define HAVE_LIMITS_H 1 #define HAVE_STDLIB_H 1 #define HAVE_STRING_H 1 #define HAVE_STDLIB_H 1 #define HAVE_MALLOC 1 #define HAVE_MEMSET 1 configure: exit 0 redland/tools/NEWS0000644000176200001440000000000007033341020013500 0ustar liggesusersredland/tools/config.status0000755000176200001440000007230712643553533015562 0ustar liggesusers#! /bin/sh # Generated by configure. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=${CONFIG_SHELL-/bin/sh} export SHELL ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by redland $as_me 1.0.14, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " # Files that config.status was made for. config_files=" Makefile" config_commands=" depfiles" ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE Configuration files: $config_files Configuration commands: $config_commands Report bugs to the package provider." ac_cs_config="" ac_cs_version="\ redland config.status 1.0.14 configured by ./configure, generated by GNU Autoconf 2.69, with options \"$ac_cs_config\" Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='/Users/jones/development/redland-bindings/R/redland/tools' srcdir='.' INSTALL='/opt/local/bin/ginstall -c' MKDIR_P='/opt/local/bin/gmkdir -p' AWK='gawk' test -n "$AWK" || AWK=awk # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --he | --h | --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi if $ac_cs_recheck; then set X /bin/sh './configure' $ac_configure_extra_args --no-create --no-recursion shift $as_echo "running CONFIG_SHELL=/bin/sh $*" >&6 CONFIG_SHELL='/bin/sh' export CONFIG_SHELL exec "$@" fi exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 # # INIT-COMMANDS # AMDEP_TRUE="" ac_aux_dir="." # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && cat >>"$ac_tmp/subs1.awk" <<\_ACAWK && S["am__EXEEXT_FALSE"]="" S["am__EXEEXT_TRUE"]="#" S["LTLIBOBJS"]="" S["RASQAL_LDFLAGS"]="-L/opt/local/lib -lrasqal -lraptor2 " S["RAPTOR_LDFLAGS"]="-L/opt/local/lib -lraptor2 " S["LIBRDF_LDFLAGS"]=" -L/opt/local/lib -lrdf " S["LIBRDF_CPPFLAGS"]=" -I/opt/local/include -I/opt/local/include/rasqal -I/opt/local/include/raptor2 " S["LIBOBJS"]="" S["EGREP"]="/usr/bin/grep -E" S["GREP"]="/usr/bin/grep" S["CPP"]="gcc -E" S["PKG_CONFIG"]="pkg-config" S["R"]="R" S["am__fastdepCC_FALSE"]="" S["am__fastdepCC_TRUE"]="#" S["CCDEPMODE"]="depmode=none" S["am__nodep"]="_no" S["AMDEPBACKSLASH"]="\\" S["AMDEP_FALSE"]="#" S["AMDEP_TRUE"]="" S["am__quote"]="" S["am__include"]="include" S["DEPDIR"]=".deps" S["OBJEXT"]="o" S["EXEEXT"]="" S["ac_ct_CC"]="gcc" S["CPPFLAGS"]="" S["LDFLAGS"]="" S["CFLAGS"]="-g -O2" S["CC"]="gcc" S["MAINT"]="#" S["MAINTAINER_MODE_FALSE"]="" S["MAINTAINER_MODE_TRUE"]="#" S["AM_BACKSLASH"]="\\" S["AM_DEFAULT_VERBOSITY"]="1" S["AM_DEFAULT_V"]="$(AM_DEFAULT_VERBOSITY)" S["AM_V"]="$(V)" S["am__untar"]="$${TAR-tar} xf -" S["am__tar"]="$${TAR-tar} chof - \"$$tardir\"" S["AMTAR"]="$${TAR-tar}" S["am__leading_dot"]="." S["SET_MAKE"]="" S["AWK"]="gawk" S["mkdir_p"]="$(MKDIR_P)" S["MKDIR_P"]="/opt/local/bin/gmkdir -p" S["INSTALL_STRIP_PROGRAM"]="$(install_sh) -c -s" S["STRIP"]="" S["install_sh"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/install-sh" S["MAKEINFO"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing makeinfo" S["AUTOHEADER"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing autoheader" S["AUTOMAKE"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing automake-1.15" S["AUTOCONF"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing autoconf" S["ACLOCAL"]="${SHELL} /Users/jones/development/redland-bindings/R/redland/tools/missing aclocal-1.15" S["VERSION"]="1.0.14" S["PACKAGE"]="redland" S["CYGPATH_W"]="echo" S["am__isrc"]="" S["INSTALL_DATA"]="${INSTALL} -m 644" S["INSTALL_SCRIPT"]="${INSTALL}" S["INSTALL_PROGRAM"]="${INSTALL}" S["target_alias"]="" S["host_alias"]="" S["build_alias"]="" S["LIBS"]="" S["ECHO_T"]="" S["ECHO_N"]="" S["ECHO_C"]="\\c" S["DEFS"]="-DPACKAGE_NAME=\\\"redland\\\" -DPACKAGE_TARNAME=\\\"redland\\\" -DPACKAGE_VERSION=\\\"1.0.14\\\" -DPACKAGE_STRING=\\\"redland\\ 1.0.14\\\" -DPACKAGE_BUGREPORT=\\\"\\\" "\ "-DPACKAGE_URL=\\\"\\\" -DPACKAGE=\\\"redland\\\" -DVERSION=\\\"1.0.14\\\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STR"\ "ING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_LIMITS_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRI"\ "NG_H=1 -DHAVE_STDLIB_H=1 -DHAVE_MALLOC=1 -DHAVE_MEMSET=1" S["mandir"]="${datarootdir}/man" S["localedir"]="${datarootdir}/locale" S["libdir"]="${exec_prefix}/lib" S["psdir"]="${docdir}" S["pdfdir"]="${docdir}" S["dvidir"]="${docdir}" S["htmldir"]="${docdir}" S["infodir"]="${datarootdir}/info" S["docdir"]="${datarootdir}/doc/${PACKAGE_TARNAME}" S["oldincludedir"]="/usr/include" S["includedir"]="${prefix}/include" S["localstatedir"]="${prefix}/var" S["sharedstatedir"]="${prefix}/com" S["sysconfdir"]="${prefix}/etc" S["datadir"]="${datarootdir}" S["datarootdir"]="${prefix}/share" S["libexecdir"]="${exec_prefix}/libexec" S["sbindir"]="${exec_prefix}/sbin" S["bindir"]="${exec_prefix}/bin" S["program_transform_name"]="s,x,x," S["prefix"]="/usr/local" S["exec_prefix"]="${prefix}" S["PACKAGE_URL"]="" S["PACKAGE_BUGREPORT"]="" S["PACKAGE_STRING"]="redland 1.0.14" S["PACKAGE_VERSION"]="1.0.14" S["PACKAGE_TARNAME"]="redland" S["PACKAGE_NAME"]="redland" S["PATH_SEPARATOR"]=":" S["SHELL"]="/bin/sh" _ACAWK cat >>"$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 fi # test -n "$CONFIG_FILES" eval set X " :F $CONFIG_FILES :C $CONFIG_COMMANDS" shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # case $INSTALL in [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; esac ac_MKDIR_P=$MKDIR_P case $MKDIR_P in [\\/$]* | ?:[\\/]* ) ;; */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; esac # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} ac_datarootdir_hack=' s&@datadir@&${datarootdir}&g s&@docdir@&${datarootdir}/doc/${PACKAGE_TARNAME}&g s&@infodir@&${datarootdir}/info&g s&@localedir@&${datarootdir}/locale&g s&@mandir@&${datarootdir}/man&g s&\${datarootdir}&${prefix}/share&g' ;; esac ac_sed_extra="/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// } :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t s&@MKDIR_P@&$ac_MKDIR_P&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 $as_echo "$as_me: executing $ac_file commands" >&6;} ;; esac case $ac_file$ac_mode in "depfiles":C) test x"$AMDEP_TRUE" != x"" || { # Older Autoconf quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. case $CONFIG_FILES in *\'*) eval set x "$CONFIG_FILES" ;; *) set x $CONFIG_FILES ;; esac shift for mf do # Strip MF so we end up with the name of the file. mf=`echo "$mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile or not. # We used to match only the files named 'Makefile.in', but # some people rename them; so instead we look at the file content. # Grep'ing the first line is not enough: some people post-process # each Makefile.in and add a new line on top of each file to say so. # Grep'ing the whole file is not good either: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then dirpart=`$as_dirname -- "$mf" || $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$mf" : 'X\(//\)[^/]' \| \ X"$mf" : 'X\(//\)$' \| \ X"$mf" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$mf" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` else continue fi # Extract the definition of DEPDIR, am__include, and am__quote # from the Makefile without running 'make'. DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` test -z "$DEPDIR" && continue am__include=`sed -n 's/^am__include = //p' < "$mf"` test -z "$am__include" && continue am__quote=`sed -n 's/^am__quote = //p' < "$mf"` # Find all dependency output files, they are included files with # $(DEPDIR) in their names. We invoke sed twice because it is the # simplest approach to changing $(DEPDIR) to its actual value in the # expansion. for file in `sed -n " s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do # Make sure the directory exists. test -f "$dirpart/$file" && continue fdir=`$as_dirname -- "$file" || $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$file" : 'X\(//\)[^/]' \| \ X"$file" : 'X\(//\)$' \| \ X"$file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir=$dirpart/$fdir; as_fn_mkdir_p # echo "creating $dirpart/$file" echo '# dummy' > "$dirpart/$file" done done } ;; esac done # for ac_tag as_fn_exit 0 redland/tools/winlibs.R0000644000176200001440000000055412654540057014631 0ustar liggesusers# Build against mingw-w64 build of redland if(!file.exists("../windows/redland-1.0.17/include/redland.h")){ if(getRversion() < "3.3.0") setInternet2() download.file("https://github.com/rwinlib/redland/archive/v1.0.17.zip", "lib.zip", quiet = TRUE) dir.create("../windows", showWarnings = FALSE) unzip("lib.zip", exdir = "../windows") unlink("lib.zip") } redland/README.md0000644000176200001440000001564414566244056013170 0ustar liggesusers## redland [![CRAN_Status_Badge](https://www.r-pkg.org/badges/version/redland)](https://cran.r-project.org/package=redland) ![CRAN Downloads](https://cranlogs.r-pkg.org/badges/redland) - **Authors**: Matthew B. Jones, Peter Slaughter, Jeroen Ooms, Carl Boettiger, and Scott Chamberlain ([NCEAS](https://www.nceas.ucsb.edu)) - [doi:10.5063/F1VM496B](https://doi.org/10.5063/F1VM496B) - **License**: [Apache 2](https://opensource.org/license/apache-2-0) - [Package source code on Github](https://github.com/ropensci/redland-bindings) - [**Submit Bugs and feature requests**](https://github.com/ropensci/redland-bindings/issues) The R package `redland` provides methods to create, query and write information stored in the Resource Description Framework (RDF). An introduction to RDF can be found at https://www.w3.org/TR/rdf-primer. In brief, RDF provides a structured graph consisting of Statements composed of Subject, Predicate, and Object Nodes. This package is implemented as R scripts that provide an R interface (aka "wrapper") to the Redland RDF C libraries that are described at https://librdf.org/docs/api/index.html. Additional information about the software that provides the connection or 'bindings' between R and the Redland RDF C libraries is available at https://github.com/ropensci/redland-bindings/tree/master/R. In this redland R package, S4 classes are used to model RDF data structures. A `redland::Statement` is composed of `redland::Node`s representing the subject, predicate, and object of each triple statement. Statements can be composed into a graph by adding them to a `redland::Model`, which in turn can be serialized and deserialized to RDF's text formats using `redland::Serializer` and `redland::Parser`, respectively. See the `redland_overview` vignette for a brief example of usage. ## Installation Notes The *redland* R package is now available from CRAN. Before the `redland` R package can be installed, the Redland C libraries may need to be installed, depending on the platform type you are installing to and whether or not you wish to install from source. ### Installing on Mac OS X On Mac OS X, the binary build from CRAN can be installed without installing the Redland C libraries by typing the following commands in the R console: ``` install.packages("redland") library(redland) ``` The *redland* R package should be available for use at this point. Alternatively, to install *redland* from source, please continue reading this section. The required Redland C libraries can be installed with either [Mac Ports](https://www.macports.org) package manager or the [HomeBrew](https://brew.sh) package manager. The HomeBrew package manager can be significantly faster to install but either one will work provided the directions shown below are followed. You can check if you have MacPorts installed by entering the following command in a terminal window: ``` port version ``` #### Installing on Mac OS X with Macports If you are already using the MacPorts package manager, you can install *redland* with the following commands, otherwise, it is recommended that you skip to the next section *Installing with HomeBrew*. To install the *redland* R package with MacPorts, enter these commands at a terminal window: ``` sudo port install redland ``` Then enter these commands in the R console: ``` install.packages("redland", type="source") library(redland) ``` Please note that the *install.packages* command specifies a "source" installation. Installing from source is only necessary if Macports is being used, and is not a requirement if Homebrew is used. The *redland* R package should be available for use at this point #### Installing on Mac OS X with HomeBrew On Mac OS X you can use the package management system [HomeBrew](https://brew.sh) to install the necessary libraries. The HomeBrew software can be installed with the following command entered at a terminal window: ``` ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" ``` Once HomeBrew has been installed, you can then enter the following command to install the Redland C libraries: ``` brew install redland ``` Next, install the *redland* R package with these commands typed at the R console window: ``` install.packages("redland", type="source") library(redland) ``` The *redland* R package should be available for use at this point. ## Installing on Ubuntu For ubuntu, install the required Redland C libraries: ``` sudo apt-get update sudo apt-get install librdf0 librdf0-dev ``` Then install the R packages from the R console: ``` install.packages("redland") library(redland) ``` ## Installing on Windows For windows, the redland R package is distributed as a binary release, and it is not necessary to install any additional system libraries. To install the R packages from the R console: ``` install.packages("redland") library(redland) ``` ## Example Usage The `redland` library can be used for a wide variety of RDF parsing and creation tasks. Some examples are provided in the `redland_overview` vignette. As a quick start, here is an example that creates an RDF graph using an in-memory storage model, adds some triples, and then serializes the graph to disk. ```r library(redland) # World is the redland mechanism for scoping models world <- new("World") # Storage provides a mechanism to store models; in-memory hashes are convenient for small models storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") # A model is a set of Statements, and is associated with a particular Storage instance model <- new("Model", world=world, storage, options="") # Add some Dublin Core properties to the model dc <- "https://purl.org/dc/elements/1.1/" stmt <- new("Statement", world=world, subject="https://ropensci.org/", predicate=paste0(dc, "title"), object="ROpenSci") addStatement(model, stmt) stmt <- new("Statement", world=world, subject="https://ropensci.org/", predicate=paste0(dc, "language"), object="en") addStatement(model, stmt) stmt <- new("Statement", world=world, subject="https://ropensci.org/", predicate=paste0(dc, "license"), object="https://creativecommons.org/licenses/by/2.0/") addStatement(model, stmt) # Serialize the model to a TTL file serializer <- new("Serializer", world, name="turtle", mimeType="text/turtle") status <- setNameSpace(serializer, world, namespace="https://purl.org/dc/elements/1.1/", prefix="dc") filePath <- tempfile(pattern = "file", tmpdir = tempdir(), fileext = ".ttl") status <- serializeToFile(serializer, world, model, filePath) readLines(file(filePath)) ``` ## Acknowledgments Work on this package was supported by: - NSF-ABI grant #1262458 to C. Gries, M. Jones, and S. Collins. - NSF-OPP grant #2042102 to M. Jones, A. Budden, M. Schildhauer, and J. Dozier [![nceas_footer](https://www.nceas.ucsb.edu/files/newLogo_0.png)](https://www.nceas.ucsb.edu) [![ropensci_footer](https://ropensci.org/public_images/github_footer.png)](https://ropensci.org) redland/build/0000755000176200001440000000000015116115726012767 5ustar liggesusersredland/build/vignette.rds0000644000176200001440000000032215116115726015323 0ustar liggesusersb```b`aeb`b2 1# ')JMIK/K-*L- MAS U&%=$7M@ U@T ּb4c]R RR@g;<E T [fN*ސ89]1 棸(\^P44@btr$$ redland/configure0000755000176200001440000000571115116115727013604 0ustar liggesusers#!/bin/sh # Anticonf (tm) script by Jeroen Ooms (2017) # This script will query 'pkg-config' for the required cflags and ldflags. # If pkg-config is unavailable or does not find the library, try setting # INCLUDE_DIR and LIB_DIR manually via e.g: # R CMD INSTALL --configure-vars='INCLUDE_DIR=/.../include LIB_DIR=/.../lib' # Library settings PKG_CONFIG_NAME="redland" PKG_DEB_NAME="librdf0-dev" PKG_RPM_NAME="redland-devel" PKG_BREW_NAME="redland" PKG_TEST_HEADER="" PKG_LIBS="-lrdf" PKG_CFLAGS="" # Use pkg-config if available pkg-config --exists ${PKG_CONFIG_NAME} >/dev/null 2>&1 && R_HAS_PKG_CONFIG=1; platform=`uname` # Use pkg-config if available if [ $R_HAS_PKG_CONFIG ]; then echo "Found pkg-config ${PKG_CONFIG_NAME}" PKGCONFIG_CFLAGS=`pkg-config --cflags --silence-errors ${PKG_CONFIG_NAME}` PKGCONFIG_LIBS=`pkg-config --libs ${PKG_CONFIG_NAME}` fi # Note that cflags may be empty in case of success if [ "$INCLUDE_DIR" ] || [ "$LIB_DIR" ]; then echo "Found INCLUDE_DIR and/or LIB_DIR!" PKG_CFLAGS="-I$INCLUDE_DIR $PKG_CFLAGS" PKG_LIBS="-L$LIB_DIR $PKG_LIBS" elif [ "$PKGCONFIG_CFLAGS" ] || [ "$PKGCONFIG_LIBS" ]; then echo "Found pkg-config cflags and libs!" PKG_CFLAGS=${PKGCONFIG_CFLAGS} PKG_LIBS=${PKGCONFIG_LIBS} elif [ "$platform" = "Darwin" ]; then brew list ${PKG_BREW_NAME} >/dev/null 2>&1 if [ $? -eq 0 ]; then echo "Configuring with brew." BREWDIR=`brew --prefix` PKG_CFLAGS=`$BREWDIR/opt/pkg-config/bin/pkg-config --cflags ${PKG_CONFIG_NAME}` PKG_LIBS=`$BREWDIR/opt/pkg-config/bin/pkg-config --libs --static ${PKG_CONFIG_NAME}` else echo "Configuring with autobrew." curl -sfL "https://autobrew.github.io/scripts/${PKG_BREW_NAME}" > autobrew . ./autobrew fi fi # For debugging echo "Using PKG_CFLAGS=$PKG_CFLAGS" echo "Using PKG_LIBS=$PKG_LIBS" # Find compiler CC=`${R_HOME}/bin/R CMD config CC` CFLAGS=`${R_HOME}/bin/R CMD config CFLAGS` CPPFLAGS=`${R_HOME}/bin/R CMD config CPPFLAGS` # Test configuration echo "#include $PKG_TEST_HEADER" | ${CC} ${CPPFLAGS} ${PKG_CFLAGS} ${CFLAGS} -E -xc - >/dev/null 2>&1 || R_CONFIG_ERROR=1; # Customize the error if [ $R_CONFIG_ERROR ]; then echo "------------------------- ANTICONF ERROR ---------------------------" echo "Configuration failed because $PKG_CONFIG_NAME was not found. Try installing:" echo " * deb: $PKG_DEB_NAME (Debian, Ubuntu, etc)" echo " * rpm: $PKG_RPM_NAME (Fedora, EPEL)" echo " * brew: $PKG_BREW_NAME (OSX)" echo "If $PKG_CONFIG_NAME is already installed, check that 'pkg-config' is in your" echo "PATH and PKG_CONFIG_PATH contains a $PKG_CONFIG_NAME.pc file. If pkg-config" echo "is unavailable you can set INCLUDE_DIR and LIB_DIR manually via:" echo "R CMD INSTALL --configure-vars='INCLUDE_DIR=... LIB_DIR=...'" echo "--------------------------------------------------------------------" exit 1; fi # Write to Makevars sed -e "s|@cflags@|$PKG_CFLAGS|" -e "s|@libs@|$PKG_LIBS|" src/Makevars.in > src/Makevars # Success exit 0 redland/man/0000755000176200001440000000000014566244056012452 5ustar liggesusersredland/man/librdf_statement_set_object.Rd0000644000176200001440000000130514156450612020457 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_set_object} \alias{librdf_statement_set_object} \title{Set the statement object.} \usage{ librdf_statement_set_object ( statement, object ) } \arguments{ \item{statement}{librdf_statement object ("_p_librdf_statement_s")} \item{object}{librdf_node of object ("_p_librdf_node_s")} } \value{ void } \description{ Set the statement object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_world_set_feature.Rd0000644000176200001440000000145714156450612017777 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_world_set_feature} \alias{librdf_world_set_feature} \title{Set the value of a world feature.} \usage{ librdf_world_set_feature ( world, feature, value, .copy ) } \arguments{ \item{world}{librdf_world object ("_p_librdf_world_s")} \item{feature}{librdf_uri feature property ("_p_librdf_uri_s")} \item{value}{librdf_node feature property value ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Set the value of a world feature. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/roclet_process.roclet_mergeNamespace.Rd0000644000176200001440000000134414566231540022246 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/mergeNamespace_roclet.R \name{roclet_process.roclet_mergeNamespace} \alias{roclet_process.roclet_mergeNamespace} \title{Roxygen process function for the 'mergeNamespace' roclet} \usage{ \method{roclet_process}{roclet_mergeNamespace}(x, blocks, env, base_path) } \arguments{ \item{x}{the currently running roclet} \item{blocks}{the documentation blocks} \item{env}{the current env} \item{base_path}{the top directory of the R package} } \description{ This function is called by the Roxygen2 roxygenize function. } \details{ This function loads the Redland interface file and tests each loaded function to see if it should be exported via the NAMESPACE file. } redland/man/librdf_free_storage.Rd0000644000176200001440000000121114156450611016712 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_storage} \alias{librdf_free_storage} \title{Destructor - destroy a librdf_storage object.} \usage{ librdf_free_storage ( storage ) } \arguments{ \item{storage}{librdf_storage object ("_p_librdf_storage_s")} } \value{ void } \description{ Destructor - destroy a librdf_storage object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Statement-initialize.Rd0000644000176200001440000000206514566231540017041 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Statement.R \name{initialize,Statement-method} \alias{initialize,Statement-method} \alias{Statement-initialize} \title{Construct a Statement object.} \usage{ \S4method{initialize}{Statement}( .Object, world, subject, predicate, object, subjectType = as.character(NA), objectType = as.character(NA), datatype_uri = as.character(NA), language = as.character(NA) ) } \arguments{ \item{.Object}{the Statement object} \item{world}{a World object} \item{subject}{a Node object} \item{predicate}{a Node object} \item{object}{a Node object} \item{subjectType}{the Node type of the subject, i.e. "blank", "uri"} \item{objectType}{the Node type of the object, i.e. "blank", "uri", "literal"} \item{datatype_uri}{the datatype URI to associate with a object literal value} \item{language}{a character value specifying the RDF language tag for an object literal value (excluding the "@" symbol), i.e. "fr"} } \value{ the Statement object } \description{ Construct a Statement object. } redland/man/Storage-initialize.Rd0000644000176200001440000000132614566231540016500 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Storage.R \name{initialize,Storage-method} \alias{initialize,Storage-method} \alias{Storage-initialize} \title{Initialize a Storage object} \usage{ \S4method{initialize}{Storage}( .Object, world, type = "hashes", name = "", options = "hash-type='memory'" ) } \arguments{ \item{.Object}{the Storage object} \item{world}{the World object} \item{type}{the Redland storage type} \item{name}{storage instance name} \item{options}{storage options} } \value{ the Storage object } \description{ Initialize a Storage object } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") } redland/man/addStatement.Rd0000644000176200001440000000117414566231540015353 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Model.R \name{addStatement} \alias{addStatement} \alias{addStatement,Model,Statement-method} \title{Add a Statement object to the Model} \usage{ addStatement(.Object, statement) \S4method{addStatement}{Model,Statement}(.Object, statement) } \arguments{ \item{.Object}{a Model object} \item{statement}{the Statement that will be added} } \description{ Add a Statement object to the Model } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") } redland/man/librdf_model_set_feature.Rd0000644000176200001440000000145714156450611017747 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_set_feature} \alias{librdf_model_set_feature} \title{Set the value of a graph feature.} \usage{ librdf_model_set_feature ( model, feature, value, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{feature}{librdf_uri feature property ("_p_librdf_uri_s")} \item{value}{librdf_node feature property value ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Set the value of a graph feature. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_context_add_statements.Rd0000644000176200001440000000152614156450611022201 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_context_add_statements} \alias{librdf_model_context_add_statements} \title{Add statements to a model with a context.} \usage{ librdf_model_context_add_statements ( model, context, stream, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{context}{librdf_node context ("_p_librdf_node_s")} \item{stream}{librdf_stream stream object ("_p_librdf_stream_s")} \item{.copy}{NA} } \value{ integer } \description{ Add statements to a model with a context. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_serializer_set_namespace.Rd0000644000176200001440000000147614156450612021323 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_serializer_set_namespace} \alias{librdf_serializer_set_namespace} \title{Set a namespace URI/prefix mapping.} \usage{ librdf_serializer_set_namespace ( serializer, nspace, prefix, .copy ) } \arguments{ \item{serializer}{serializer object ("_p_librdf_serializer_s")} \item{nspace}{URI of namespace or NULL ("_p_librdf_uri_s")} \item{prefix}{prefix to use or NULL ("character")} \item{.copy}{NA} } \value{ integer } \description{ Set a namespace URI/prefix mapping. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_uri.Rd0000644000176200001440000000114714156450611016720 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_uri} \alias{librdf_node_get_uri} \title{Get the URI for a node object.} \usage{ librdf_node_get_uri ( node ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} } \value{ _p_librdf_uri_s } \description{ Get the URI for a node object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_set_offset.Rd0000644000176200001440000000141414156450612017641 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_set_offset} \alias{librdf_query_set_offset} \title{Set the query-specified offset on results.} \usage{ librdf_query_set_offset ( query, offset, .copy ) } \arguments{ \item{query}{librdf_query query object ("_p_librdf_query")} \item{offset}{offset for results, >=0 to set an offset, <0 to have no offset ("integer")} \item{.copy}{NA} } \value{ integer } \description{ Set the query-specified offset on results. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_world_open.Rd0000644000176200001440000000116414156450612016425 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_world_open} \alias{librdf_world_open} \title{Open a created redland world environment.} \usage{ librdf_world_open ( world ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} } \value{ void } \description{ Open a created redland world environment. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_statement_set_predicate.Rd0000644000176200001440000000133514156450612021154 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_set_predicate} \alias{librdf_statement_set_predicate} \title{Set the statement predicate.} \usage{ librdf_statement_set_predicate ( statement, predicate ) } \arguments{ \item{statement}{librdf_statement object ("_p_librdf_statement_s")} \item{predicate}{librdf_node of predicate ("_p_librdf_node_s")} } \value{ void } \description{ Set the statement predicate. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_uri.Rd0000644000176200001440000000133414156450611015723 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_uri} \alias{librdf_new_uri} \title{Constructor - create a new librdf_uri object from a URI string.} \usage{ librdf_new_uri ( world, string ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{string}{URI in string form ("character")} } \value{ _p_librdf_uri_s } \description{ Constructor - create a new librdf_uri object from a URI string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/roclet_output.roclet_mergeNamespace.Rd0000644000176200001440000000161414566231540022130 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/mergeNamespace_roclet.R \name{roclet_output.roclet_mergeNamespace} \alias{roclet_output.roclet_mergeNamespace} \title{Roxygen output function that merges a base NAMESPACE file with the Roxygen dynamically created NAMSPACE file} \usage{ \method{roclet_output}{roclet_mergeNamespace}(x, results, base_path, ...) } \arguments{ \item{x}{the currently running roclet} \item{results}{the list of items to process that was generated by the roc_process.mergedNamespace function} \item{base_path}{the base directory path of the package} \item{...}{additional parameters} } \description{ The 'roclet_output' function handles output of the results from the 'roc_process' function. This function merges the NAMESPACE file created by the 'namespace' roclet with the list of Redland RDF functions determined by the 'roc_process' function. } redland/man/librdf_model_contains_statement.Rd0000644000176200001440000000136214156450611021336 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_contains_statement} \alias{librdf_model_contains_statement} \title{Check for a statement in the model.} \usage{ librdf_model_contains_statement ( model, statement, .copy ) } \arguments{ \item{model}{the model object ("_p_librdf_model_s")} \item{statement}{the statement ("_p_librdf_statement_s")} \item{.copy}{NA} } \value{ integer } \description{ Check for a statement in the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_copyright_string_get.Rd0000644000176200001440000000101714156450611020506 0ustar liggesusers\name{librdf_copyright_string_get} \alias{librdf_copyright_string_get} \title{Return Redland RDF copyright string} \usage{ librdf_copyright_string_get (.copy) } \arguments{ \item{.copy}{logical} } \value{ character } \description{ Return the Redland RDF copyright } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Statement-class.Rd0000644000176200001440000000466314566244056016021 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Statement.R \docType{class} \encoding{UTF-8} \name{Statement-class} \alias{Statement-class} \alias{Statement} \title{An RDF Statement object} \description{ A Statement object is created using the provided subject, predicate and object. } \details{ A Statement object can be created from Node objects that are provided for the subject, predicate and object. An alternative way to create a Statement object is to provide the subject, predicate and object as character values. If this later method is used, the character values will be evaluated to determine the appropriate RDF type for the subject and object. Note that the RDF type for the predicate will always be 'uri' (aka 'resource'). If the automatic determination of RDF types is not desired, then the \code{subjectType} and \code{objectType} parameters can be specified to explicitly set the RDF types. } \section{Slots}{ \describe{ \item{\code{librdf_statement}}{A redland statement object} }} \section{Methods}{ \itemize{ \code{\link{Statement-initialize}}: Initialize a Statement object. \code{\link{getTermType}}: Return the redland node type for the specified RDF term in a statement. \code{\link{freeStatement}}: Free memory used by a librdf statement. } } \examples{ world <- new("World") # Create nodes manually and add to the statment subject <- new("Node", blank="_:myid1", world) predicate <- new("Node", uri="http://www.example.com/isa", world) object <- new("Node", literal="thing", world) stmt <- new("Statement", world, subject, predicate, object) # Create the statement specifying node values directly stmt <- new("Statement", world, subject="http://www.example.com/myevent", predicate="http://example.com/occurredAt", object="Tue Feb 17 14:05:13 PST 2015") stmt <- new("Statement", world, subject=NULL, predicate="http://www.example.com/hasAddr", object="http://www.nothing.com", objectType="literal") stmt <- new("Statement", world, subject="http://www.example.com/BobSmith", predicate="http://www.example.com/says", object="¡Hola, amigo! ¿Cómo estás?", objectType="literal", language="es") } \seealso{ \code{\link{redland}}: redland package } \keyword{classes} redland/man/librdf_version_release.Rd0000644000176200001440000000116414156450612017442 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_version_release} \alias{librdf_version_release} \title{Library release version number as a decimal integer.} \usage{ librdf_version_release ( .copy ) } \arguments{ \item{.copy}{NA} } \value{ integer } \description{ Library release version number as a decimal integer. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Serializer-class.Rd0000644000176200001440000000272514566244056016163 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Serializer.R \docType{class} \name{Serializer-class} \alias{Serializer-class} \alias{Serializer} \title{An RDF Serializer object.} \description{ The Serializer class provides methods to convert a Model object to other forms, for example, write out a Model to a file. } \section{Slots}{ \describe{ \item{\code{librdf_serializer}}{A redland statement object} }} \section{Methods}{ \itemize{ \code{\link{Serializer-initialize}}: Initialize a Serializer object. \code{\link{setNameSpace}}: Set a namespace for the serializer. \code{\link{serializeToCharacter}}: Serialize a model to a character vector. \code{\link{serializeToFile}}: Serialize a model to a file. \code{\link{freeSerializer}}: Free memory used by a librdf serializer. } } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") filePath <- system.file("extdata/example.rdf", package="redland") parser <- new("Parser", world) parseFileIntoModel(parser, world, filePath, model) # Creat the default "rdfxml" serizlizer serializer <- new("Serializer", world) # Add a namespace definition to the serializer status <- setNameSpace(serializer, world, namespace="http://purl.org/dc/elements/1.1/", prefix="dc") rdf <- serializeToCharacter(serializer, world, model, baseUri="") } \seealso{ \code{\link{redland}}: redland package } \keyword{classes} redland/man/librdf_free_digest.Rd0000644000176200001440000000116614156450611016536 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_digest} \alias{librdf_free_digest} \title{Destructor - destroy a librdf_digest object.} \usage{ librdf_free_digest ( digest ) } \arguments{ \item{digest}{the digest ("_p_librdf_digest_s")} } \value{ void } \description{ Destructor - destroy a librdf_digest object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/freeQueryResults.Rd0000644000176200001440000000100214566231540016255 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/QueryResults.R \name{freeQueryResults} \alias{freeQueryResults} \alias{freeQueryResults,QueryResults-method} \title{Free memory used by a librdf query results} \usage{ freeQueryResults(.Object) \S4method{freeQueryResults}{QueryResults}(.Object) } \arguments{ \item{.Object}{a QueryResults object} } \description{ After this method is called, the QueryResults object is no longer usable and should be deleted with \code{"rm(query)"}. } redland/man/raptor_version_release_get.Rd0000644000176200001440000000077414156450613020355 0ustar liggesusers\name{raptor_version_release_get} \alias{raptor_version_release_get} \title{Raptor library release.} \usage{ raptor_version_release_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Get Raptor library release. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_statement_get_object.Rd0000644000176200001440000000121514156450612020443 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_get_object} \alias{librdf_statement_get_object} \title{Get the statement object.} \usage{ librdf_statement_get_object ( statement ) } \arguments{ \item{statement}{librdf_statement object ("_p_librdf_statement_s")} } \value{ _p_librdf_node_s } \description{ Get the statement object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_has_arc_out.Rd0000644000176200001440000000151714156450611017725 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_has_arc_out} \alias{librdf_model_has_arc_out} \title{Check if a node has a given property pointing from it.} \usage{ librdf_model_has_arc_out ( model, node, property, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{node}{librdf_node resource node ("_p_librdf_node_s")} \item{property}{librdf_node property node ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Check if a node has a given property pointing from it. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_version_decimal_get.Rd0000644000176200001440000000100714156450612020253 0ustar liggesusers\name{librdf_version_decimal_get} \alias{librdf_version_decimal_get} \title{Return Redland librdf copyright} \usage{ librdf_version_decimal_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Return Redland librdf copyright } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_version_decimal.Rd0000644000176200001440000000100114156450613017454 0ustar liggesusers\name{raptor_version_decimal} \alias{raptor_version_decimal} \title{Raptor version as a decimal number} \usage{ raptor_version_decimal ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Raptor version as a decimal number } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_locator_byte.Rd0000644000176200001440000000110614156450612017004 0ustar liggesusers\name{raptor_locator_byte} \alias{raptor_locator_byte} \title{Get the locator byte offset from locator.} \usage{ raptor_locator_byte ( locator, .copy ) } \arguments{ \item{locator}{raptor locator ("_p_raptor_locator")} \item{.copy}{logical} } \value{ character } \description{ Get the locator byte offset from locator } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/rasqal_version_major.Rd0000644000176200001440000000075714156450613017163 0ustar liggesusers\name{rasqal_version_major} \alias{rasqal_version_major} \title{Rasqal major version number.} \usage{ rasqal_version_major ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Rasqal major version number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_digest.Rd0000644000176200001440000000134014156450611016400 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_digest} \alias{librdf_new_digest} \title{Constructor - create a new librdf_digest object.} \usage{ librdf_new_digest ( world, name ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{the digest name to use to create this digest ("character")} } \value{ _p_librdf_digest_s } \description{ Constructor - create a new librdf_digest object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_literal_value.Rd0000644000176200001440000000127314156450611020751 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_literal_value} \alias{librdf_node_get_literal_value} \title{Get the literal value of the node as a UTF-8 encoded string.} \usage{ librdf_node_get_literal_value ( node ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} } \value{ character } \description{ Get the literal value of the node as a UTF-8 encoded string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_add_string_literal_statement.Rd0000644000176200001440000000211114156450611023343 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_add_string_literal_statement} \alias{librdf_model_add_string_literal_statement} \title{Create and add a new statement about a literal to the model.} \usage{ librdf_model_add_string_literal_statement ( model, subject, predicate, literal, inStrOrNull, is_wf_xml, .copy ) } \arguments{ \item{model}{model object ("_p_librdf_model_s")} \item{subject}{librdf_node of subject ("_p_librdf_node_s")} \item{predicate}{librdf_node of predicate ("_p_librdf_node_s")} \item{literal}{string literal conten ("character")} \item{inStrOrNull}{language of literal ("character")} \item{is_wf_xml}{literal is XML ("integer")} \item{.copy}{NA} } \value{ integer } \description{ Create and add a new statement about a literal to the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_as_stream.Rd0000644000176200001440000000135314156450612021241 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_as_stream} \alias{librdf_query_results_as_stream} \title{Get a query result as an RDF graph in librdf_stream form} \usage{ librdf_query_results_as_stream ( query_results ) } \arguments{ \item{query_results}{librdf_query_results query_results ("_p_librdf_query_results")} } \value{ _p_librdf_stream_s } \description{ Get a query result as an RDF graph in librdf_stream form } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_literal_value_language.Rd0000644000176200001440000000124014156450611022606 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_literal_value_language} \alias{librdf_node_get_literal_value_language} \title{Get the XML language of the node.} \usage{ librdf_node_get_literal_value_language ( node ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} } \value{ character } \description{ Get the XML language of the node. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_context_add_statement.Rd0000644000176200001440000000154414156450611022016 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_context_add_statement} \alias{librdf_model_context_add_statement} \title{Add a statement to a model with a context.} \usage{ librdf_model_context_add_statement ( model, context, statement, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{context}{librdf_node context ("_p_librdf_node_s")} \item{statement}{librdf_statement statement object ("_p_librdf_statement_s")} \item{.copy}{NA} } \value{ integer } \description{ Add a statement to a model with a context. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/getBlankNodeId.Rd0000644000176200001440000000162114566231540015545 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Node.R \name{getBlankNodeId} \alias{getBlankNodeId} \alias{getBlankNodeId,Node-method} \title{Get the blank identifier that has been assigned for a specified Node object} \usage{ getBlankNodeId(.Object) \S4method{getBlankNodeId}{Node}(.Object) } \arguments{ \item{.Object}{a Node object} } \value{ a blank node identifier } \description{ Get the blank identifier that has been assigned for a specified Node object } \details{ When a Node object is initialized with no value specified, i.e. node <- Node(""), a blank node is created and a locally unique identifier is generated by librdf. This method retrieves this identifier and returns in to the caller. } \examples{ world <- new("World") # a blank node is created with a unique identifier generated by librdf node <- new("Node", world, blank=NULL) nodeId <- getBlankNodeId(node) } redland/man/librdf_query_results_get_boolean.Rd0000644000176200001440000000130214156450612021533 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_get_boolean} \alias{librdf_query_results_get_boolean} \title{Get boolean query result.} \usage{ librdf_query_results_get_boolean ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results query_results ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Get boolean query result. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_statement_set_subject.Rd0000644000176200001440000000131514156450612020651 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_set_subject} \alias{librdf_statement_set_subject} \title{Set the statement subject.} \usage{ librdf_statement_set_subject ( statement, subject ) } \arguments{ \item{statement}{librdf_statement object ("_p_librdf_statement_s")} \item{subject}{librdf_node of subject ("_p_librdf_node_s")} } \value{ void } \description{ Set the statement subject. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_target.Rd0000644000176200001440000000157014156450611017562 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_target} \alias{librdf_model_get_target} \title{Return one target (object) of an arc in an RDF graph given source (subject) and arc (predicate).} \usage{ librdf_model_get_target ( model, source, arc ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{source}{librdf_node source ("_p_librdf_node_s")} \item{arc}{librdf_node arc ("_p_librdf_node_s")} } \value{ _p_librdf_node_s } \description{ Return one target (object) of an arc in an RDF graph given source (subject) and arc (predicate). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_serializer.Rd0000644000176200001440000000167514156450611017305 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_serializer} \alias{librdf_new_serializer} \title{Constructor - create a new librdf_serializer object.} \usage{ librdf_new_serializer ( world, name, mime_type, type_uri ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{the serializer factory name (or NULL or empty string if don't care) ("character")} \item{mime_type}{the MIME type of the syntax (NULL if not used) ("character")} \item{type_uri}{URI of syntax (NULL if not used) ("_p_librdf_uri_s")} } \value{ _p_librdf_serializer_s } \description{ Constructor - create a new librdf_serializer object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_get_limit.Rd0000644000176200001440000000124314156450612017455 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_get_limit} \alias{librdf_query_get_limit} \title{Get the query-specified limit on results.} \usage{ librdf_query_get_limit ( query, .copy ) } \arguments{ \item{query}{librdf_query query object ("_p_librdf_query")} \item{.copy}{NA} } \value{ integer } \description{ Get the query-specified limit on results. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_blank_identifier.Rd0000644000176200001440000000127414156450611021413 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_blank_identifier} \alias{librdf_node_get_blank_identifier} \title{Get the blank node identifier as a UTF-8 encoded string.} \usage{ librdf_node_get_blank_identifier ( node ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} } \value{ character } \description{ Get the blank node identifier as a UTF-8 encoded string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Query-initialize.Rd0000644000176200001440000000142314566231540016177 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Query.R \name{initialize,Query-method} \alias{initialize,Query-method} \alias{Query-initialize} \title{Initialize the Query object.} \usage{ \S4method{initialize}{Query}( .Object, world, querystring, base_uri = NULL, query_language = "sparql", query_uri = NULL ) } \arguments{ \item{.Object}{the Query object} \item{world}{a World object} \item{querystring}{a query string for the language specified in 'query_language'} \item{base_uri}{a URI to prepend to relative URI in the document} \item{query_language}{the query language to execute the querystring with} \item{query_uri}{a URI to prepend to terms in the query} } \value{ the Query object } \description{ Initialize the Query object. } redland/man/librdf_version_minor.Rd0000644000176200001440000000115214156450612017143 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_version_minor} \alias{librdf_version_minor} \title{Library minor version number as a decimal integer.} \usage{ librdf_version_minor ( .copy ) } \arguments{ \item{.copy}{NA} } \value{ integer } \description{ Library minor version number as a decimal integer. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_set_limit.Rd0000644000176200001440000000140414156450612017470 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_set_limit} \alias{librdf_query_set_limit} \title{Set the query-specified limit on results.} \usage{ librdf_query_set_limit ( query, limit, .copy ) } \arguments{ \item{query}{librdf_query query object ("_p_librdf_query")} \item{limit}{the limit on results, >=0 to set a limit, <0 to have no limit ("integer")} \item{.copy}{NA} } \value{ integer } \description{ Set the query-specified limit on results. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_hash_from_string.Rd0000644000176200001440000000146114156450611020461 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_hash_from_string} \alias{librdf_new_hash_from_string} \title{Constructor - create a new librdf_hash object from a string.} \usage{ librdf_new_hash_from_string ( world, name, string ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{hash name ("character")} \item{string}{hash encoded as a string ("character")} } \value{ _p_librdf_hash_s } \description{ Constructor - create a new librdf_hash object from a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_check_name.Rd0000644000176200001440000000130414156450612017702 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_check_name} \alias{librdf_parser_check_name} \title{Check if a parser name is known} \usage{ librdf_parser_check_name ( world, name, .copy ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{name of parser ("character")} \item{.copy}{NA} } \value{ integer } \description{ Check if a parser name is known } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_transaction_start.Rd0000644000176200001440000000121014156450611021166 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_transaction_start} \alias{librdf_model_transaction_start} \title{Start a transaction} \usage{ librdf_model_transaction_start ( model, .copy ) } \arguments{ \item{model}{the model object ("_p_librdf_model_s")} \item{.copy}{NA} } \value{ integer } \description{ Start a transaction } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_uri_equals.Rd0000644000176200001440000000134514156450612016427 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_uri_equals} \alias{librdf_uri_equals} \title{Compare two librdf_uri objects for equality.} \usage{ librdf_uri_equals ( first_uri, second_uri, .copy ) } \arguments{ \item{first_uri}{librdf_uri object 1 ("_p_librdf_uri_s")} \item{second_uri}{librdf_uri object 2 ("_p_librdf_uri_s")} \item{.copy}{NA} } \value{ integer } \description{ Compare two librdf_uri objects for equality. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_version_major_get.Rd0000644000176200001440000000103714156450612017770 0ustar liggesusers\name{librdf_version_major_get} \alias{librdf_version_major_get} \title{Return the Redland librdf major version number} \usage{ librdf_version_major_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Return the Redland librdf major version number } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_contexts.Rd0000644000176200001440000000123314156450611020137 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_contexts} \alias{librdf_model_get_contexts} \title{Return the list of contexts in the graph.} \usage{ librdf_model_get_contexts ( model ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} } \value{ _p_librdf_iterator_s } \description{ Return the list of contexts in the graph. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_statement_get_subject.Rd0000644000176200001440000000122214156450612020632 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_get_subject} \alias{librdf_statement_get_subject} \title{Get the statement subject.} \usage{ librdf_statement_get_subject ( statement ) } \arguments{ \item{statement}{librdf_statement object ("_p_librdf_statement_s")} } \value{ _p_librdf_node_s } \description{ Get the statement subject. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_free_stream.Rd0000644000176200001440000000120014156450611016537 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_stream} \alias{librdf_free_stream} \title{Destructor - destroy an libdf_stream object.} \usage{ librdf_free_stream ( stream ) } \arguments{ \item{stream}{librdf_stream object ("_p_librdf_stream_s")} } \value{ void } \description{ Destructor - destroy an libdf_stream object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Parser-initialize.Rd0000644000176200001440000000137314566231540016332 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Parser.R \name{initialize,Parser-method} \alias{initialize,Parser-method} \alias{Parser-initialize} \title{Initialize a Parser object.} \usage{ \S4method{initialize}{Parser}( .Object, world, name = "rdfxml", mimeType = "application/rdf+xml", typeUri = as.character(NA) ) } \arguments{ \item{.Object}{the Parser object} \item{world}{a World object} \item{name}{name of the parser factory to use} \item{mimeType}{a mime type of the syntax of the model} \item{typeUri}{a URI for the syntax of the model} } \value{ the Parser object } \description{ A Parser object is initialized for a specific RDF serialization. } \details{ The serialization format that are supported by } redland/man/librdf_new_statement_from_nodes.Rd0000644000176200001440000000165714156450611021353 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_statement_from_nodes} \alias{librdf_new_statement_from_nodes} \title{Constructor - create a new librdf_statement from existing librdf_node objects.} \usage{ librdf_new_statement_from_nodes ( world, subject, predicate, object ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{subject}{librdf_node ("_p_librdf_node_s")} \item{predicate}{librdf_node ("_p_librdf_node_s")} \item{object}{librdf_node ("_p_librdf_node_s")} } \value{ _p_librdf_statement_s } \description{ Constructor - create a new librdf_statement from existing librdf_node objects. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_size.Rd0000644000176200001440000000122214156450611016401 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_size} \alias{librdf_model_size} \title{Get the number of statements in the model.} \usage{ librdf_model_size ( model, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{.copy}{NA} } \value{ integer } \description{ Get the number of statements in the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_serializer_check_name.Rd0000644000176200001440000000133414156450612020562 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_serializer_check_name} \alias{librdf_serializer_check_name} \title{Check if a serializer name is known} \usage{ librdf_serializer_check_name ( world, name, .copy ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{name of serializer ("character")} \item{.copy}{NA} } \value{ integer } \description{ Check if a serializer name is known } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_version_release_get.Rd0000644000176200001440000000105114156450612020274 0ustar liggesusers\name{librdf_version_release_get} \alias{librdf_version_release_get} \title{Return the Redland librdf release version number} \usage{ librdf_version_release_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Return the Redland librdf release version number } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_log_message_locator.Rd0000644000176200001440000000120514156450611020260 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_log_message_locator} \alias{librdf_log_message_locator} \title{Retrieve locator of log entry.} \usage{ librdf_log_message_locator ( message ) } \arguments{ \item{message}{log message ("_p_librdf_log_message")} } \value{ _p_raptor_locator } \description{ Retrieve locator of log entry. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/subset-ExternalReference-method.Rd0000644000176200001440000000067614156450613021125 0ustar liggesusers\docType{methods} \name{[<-,ExternalReference-method} \alias{[<-,ExternalReference-method} \title{Assign values in a list of ExternalReferences} \usage{ \S4method{[}{ExternalReference}(x, i, j, ...) <- value } \arguments{ \item{x}{a list of ExternalReferences} \item{i}{row subscript} \item{j}{column subscript} \item{...}{additional arguments} \item{value}{a value to assign} } \description{ Assign values in a list of ExternalReferences } redland/man/librdf_query_results_is_syntax.Rd0000644000176200001440000000132514156450612021303 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_is_syntax} \alias{librdf_query_results_is_syntax} \title{Test if librdf_query_results is a syntax.} \usage{ librdf_query_results_is_syntax ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results object ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Test if librdf_query_results is a syntax. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_serializer_get_feature.Rd0000644000176200001440000000135014156450612020775 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_serializer_get_feature} \alias{librdf_serializer_get_feature} \title{Get the value of a serializer feature.} \usage{ librdf_serializer_get_feature ( serializer, feature ) } \arguments{ \item{serializer}{serializer object ("_p_librdf_serializer_s")} \item{feature}{URI of feature ("_p_librdf_uri_s")} } \value{ _p_librdf_node_s } \description{ Get the value of a serializer feature. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/rasqal_version_minor.Rd0000644000176200001440000000075714156450613017177 0ustar liggesusers\name{rasqal_version_minor} \alias{rasqal_version_minor} \title{Rasqal minor version number.} \usage{ rasqal_version_minor ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Rasqal minor version number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_model_with_options.Rd0000644000176200001440000000153414156450611021034 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_model_with_options} \alias{librdf_new_model_with_options} \title{Constructor - Create a new librdf_model with storage.} \usage{ librdf_new_model_with_options ( world, storage, options ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{storage}{librdf_storage storage to use ("_p_librdf_storage_s")} \item{options}{librdf_hash of options to use ("_p_librdf_hash_s")} } \value{ _p_librdf_model_s } \description{ Constructor - Create a new librdf_model with storage. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_equals.Rd0000644000176200001440000000136714156450611016560 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_equals} \alias{librdf_node_equals} \title{Compare two librdf_node objects for equality.} \usage{ librdf_node_equals ( first_node, second_node, .copy ) } \arguments{ \item{first_node}{first librdf_node node ("_p_librdf_node_s")} \item{second_node}{second librdf_node node ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Compare two librdf_node objects for equality. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_short_copyright_string_get.Rd0000644000176200001440000000105314156450612021726 0ustar liggesusers\name{librdf_short_copyright_string_get} \alias{librdf_short_copyright_string_get} \title{Return Redland librdf copyright string} \usage{ librdf_short_copyright_string_get( .copy ) } \arguments{ \item{.copy}{logical} } \value{ character } \description{ Return Redland librdf copyright string } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_parse_string_as_stream.Rd0000644000176200001440000000154014156450612022365 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_parse_string_as_stream} \alias{librdf_parser_parse_string_as_stream} \title{Parse a string of content to a librdf_stream of statements.} \usage{ librdf_parser_parse_string_as_stream ( parser, string, base_uri ) } \arguments{ \item{parser}{the parser ("_p_librdf_parser_s")} \item{string}{the string to parse ("character")} \item{base_uri}{the base URI to use or NULL ("_p_librdf_uri_s")} } \value{ _p_librdf_stream_s } \description{ Parse a string of content to a librdf_stream of statements. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_iterator_next.Rd0000644000176200001440000000123314156450611017140 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_iterator_next} \alias{librdf_iterator_next} \title{Move to the next iterator element.} \usage{ librdf_iterator_next ( iterator, .copy ) } \arguments{ \item{iterator}{the librdf_iterator object ("_p_librdf_iterator_s")} \item{.copy}{NA} } \value{ integer } \description{ Move to the next iterator element. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/setQueryResultsLimit.Rd0000644000176200001440000000105714566231540017140 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Query.R \name{setQueryResultLimit} \alias{setQueryResultLimit} \alias{setQueryResultsLimit} \alias{setQueryResultLimit,Query-method} \title{Set limit on returned query results} \usage{ setQueryResultLimit(.Object, limit) \S4method{setQueryResultLimit}{Query}(.Object, limit) } \arguments{ \item{.Object}{a Query object} \item{limit}{the result set limit. Specify a value >= to have a limit, or a value < 0 to have no limit.} } \description{ Set limit on returned query results } redland/man/World-initialize.Rd0000644000176200001440000000057214566231540016165 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/World.R \name{initialize,World-method} \alias{initialize,World-method} \alias{World-initialize} \title{Initialize the World object.} \usage{ \S4method{initialize}{World}(.Object) } \arguments{ \item{.Object}{the World object} } \value{ the World object } \description{ Initialize the World object. } redland/man/raptor_version_release.Rd0000644000176200001440000000075314156450613017513 0ustar liggesusers\name{raptor_version_release} \alias{raptor_version_release} \title{Raptor library release.} \usage{ raptor_version_release ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Raptor library release. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_li_ordinal.Rd0000644000176200001440000000123414156450611020232 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_li_ordinal} \alias{librdf_node_get_li_ordinal} \title{Get the node li object ordinal value.} \usage{ librdf_node_get_li_ordinal ( node, .copy ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Get the node li object ordinal value. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_statement_match.Rd0000644000176200001440000000143414156450612017435 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_match} \alias{librdf_statement_match} \title{Match a statement against a 'partial' statement.} \usage{ librdf_statement_match ( statement, partial_statement, .copy ) } \arguments{ \item{statement}{statement ("_p_librdf_statement_s")} \item{partial_statement}{statement with possible empty parts ("_p_librdf_statement_s")} \item{.copy}{NA} } \value{ integer } \description{ Match a statement against a 'partial' statement. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_version_major.Rd0000644000176200001440000000115214156450612017127 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_version_major} \alias{librdf_version_major} \title{Library major version number as a decimal integer.} \usage{ librdf_version_major ( .copy ) } \arguments{ \item{.copy}{NA} } \value{ integer } \description{ Library major version number as a decimal integer. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_hash.Rd0000644000176200001440000000126414156450611016051 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_hash} \alias{librdf_new_hash} \title{Constructor - create a new librdf_hash object.} \usage{ librdf_new_hash ( world, name ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{factory name ("character")} } \value{ _p_librdf_hash_s } \description{ Constructor - create a new librdf_hash object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_free_node.Rd0000644000176200001440000000115214156450611016177 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_node} \alias{librdf_free_node} \title{Destructor - destroy an librdf_node object.} \usage{ librdf_free_node ( r ) } \arguments{ \item{r}{librdf_node object ("_p_librdf_node_s")} } \value{ void } \description{ Destructor - destroy an librdf_node object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_serializer_serialize_model_to_string.Rd0000644000176200001440000000201614156450612023742 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_serializer_serialize_model_to_string} \alias{librdf_serializer_serialize_model_to_string} \title{Write a serialized librdf_model to a string. The returned string must be freed by the caller using librdf_free_memory().} \usage{ librdf_serializer_serialize_model_to_string ( serializer, inUriOrNull, model ) } \arguments{ \item{serializer}{the serializer ("_p_librdf_serializer_s")} \item{inUriOrNull}{the base URI to use (or NULL) ("_p_librdf_uri_s")} \item{model}{the librdf_model model to use ("_p_librdf_model_s")} } \value{ character } \description{ Write a serialized librdf_model to a string. The returned string must be freed by the caller using librdf_free_memory(). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_node_from_normalised_uri_string.Rd0000644000176200001440000000204014156450611023551 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node_from_normalised_uri_string} \alias{librdf_new_node_from_normalised_uri_string} \title{Constructor - create a new librdf_node object from a UTF-8 encoded URI string normalised to a new base URI.} \usage{ librdf_new_node_from_normalised_uri_string ( world, uri_string, source_uri, base_uri ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{uri_string}{UTF-8 encoded string representing a URI ("character")} \item{source_uri}{source URI ("_p_librdf_uri_s")} \item{base_uri}{base URI ("_p_librdf_uri_s")} } \value{ _p_librdf_node_s } \description{ Constructor - create a new librdf_node object from a UTF-8 encoded URI string normalised to a new base URI. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_is_resource.Rd0000644000176200001440000000117314156450612017604 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_is_resource} \alias{librdf_node_is_resource} \title{Check node is a resource.} \usage{ librdf_node_is_resource ( node, .copy ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Check node is a resource. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_digest_update_string.Rd0000644000176200001440000000130014156450611020453 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_digest_update_string} \alias{librdf_digest_update_string} \title{Add a string to the librdf_digest object.} \usage{ librdf_digest_update_string ( digest, string ) } \arguments{ \item{digest}{the digest ("_p_librdf_digest_s")} \item{string}{string to add ("character")} } \value{ void } \description{ Add a string to the librdf_digest object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/rasqal_version_string.Rd0000644000176200001440000000075714156450613017361 0ustar liggesusers\name{rasqal_version_string} \alias{rasqal_version_string} \title{Rasqal version as a string} \usage{ rasqal_version_string ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Rasqal version as a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_feature.Rd0000644000176200001440000000132114156450611017721 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_feature} \alias{librdf_model_get_feature} \title{Get the value of a graph feature .} \usage{ librdf_model_get_feature ( model, feature ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{feature}{librdf_uri feature property ("_p_librdf_uri_s")} } \value{ _p_librdf_node_s } \description{ Get the value of a graph feature . } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/is.null.externalptr.Rd0000644000176200001440000000073514566231540016673 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/util.R \name{is.null.externalptr} \alias{is.null.externalptr} \title{Determine whether an externalptr object is NULL.} \usage{ is.null.externalptr(pointer) } \arguments{ \item{pointer}{externalptr to be checked for NULL value} } \value{ logical TRUE if the pointer is NULL, otherwise FALSE } \description{ The pointer is treated as an externalptr and checked via a call in C to see if it is NULL. } redland/man/librdf_log_message_message.Rd0000644000176200001440000000121314156450611020240 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_log_message_message} \alias{librdf_log_message_message} \title{Retrieve text message from log entry.} \usage{ librdf_log_message_message ( message ) } \arguments{ \item{message}{log message ("_p_librdf_log_message")} } \value{ character } \description{ Retrieve text message from log entry. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_digest_final.Rd0000644000176200001440000000113314156450611016700 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_digest_final} \alias{librdf_digest_final} \title{Finish the digesting of data.} \usage{ librdf_digest_final ( digest ) } \arguments{ \item{digest}{the digest ("_p_librdf_digest_s")} } \value{ void } \description{ Finish the digesting of data. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_sync.Rd0000644000176200001440000000120514156450611016404 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_sync} \alias{librdf_model_sync} \title{Synchronise the model to the model implementation.} \usage{ librdf_model_sync ( model ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} } \value{ void } \description{ Synchronise the model to the model implementation. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_node.Rd0000644000176200001440000000127014156450611016050 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node} \alias{librdf_new_node} \title{Constructor - create a new librdf_node object with a private identifier.} \usage{ librdf_new_node ( world ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} } \value{ _p_librdf_node_s } \description{ Constructor - create a new librdf_node object with a private identifier. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_digest_update.Rd0000644000176200001440000000134514156450611017076 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_digest_update} \alias{librdf_digest_update} \title{Add more data to the librdf_digest object.} \usage{ librdf_digest_update ( digest, buf, length ) } \arguments{ \item{digest}{the digest ("_p_librdf_digest_s")} \item{buf}{the data buffer ("character")} \item{length}{the length of the data ("integer")} } \value{ void } \description{ Add more data to the librdf_digest object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/getResults.Rd0000644000176200001440000000352214566231540015076 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Query.R \name{getResults} \alias{getResults} \alias{getResults,Query-method} \title{Return all query results} \usage{ getResults(.Object, model, ...) \S4method{getResults}{Query}(.Object, model, formatName = "rdfxml") } \arguments{ \item{.Object}{a Query object} \item{model}{a Model object} \item{...}{additional parameters} \item{formatName}{a string specifying the RDF format name. Currently the supported formats are "rdfxml" ,"turtle", "json", "csv"} } \description{ Return all query results } \details{ After this method is called, the Query object is no longer usable and should be deleted \code{"rm(query)"} and a new object created. } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") stmt <- new("Statement", world=world, subject="https://orcid.org/0000-0002-2192-403X", predicate="http://www.w3.org/ns/prov#Agent", object="slaughter", objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") #objectType="literal", language="en") status <- addStatement(model, stmt) queryString <- paste("PREFIX orcid: ", "PREFIX dataone: ", "PREFIX prov: ", "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) # Return all results as a string results <- getResults(query, model, "rdfxml") results <- getResults(query, model, "turtle") results <- getResults(query, model, "json") # When the query object is no longer needed, the resources it had allocated can be freed. freeQuery(query) rm(query) } redland/man/librdf_free_parser.Rd0000644000176200001440000000117014156450611016546 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_parser} \alias{librdf_free_parser} \title{Destructor - destroys a librdf_parser object.} \usage{ librdf_free_parser ( parser ) } \arguments{ \item{parser}{the parser ("_p_librdf_parser_s")} } \value{ void } \description{ Destructor - destroys a librdf_parser object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_version_minor_get.Rd0000644000176200001440000000103714156450612020004 0ustar liggesusers\name{librdf_version_minor_get} \alias{librdf_version_minor_get} \title{Return the Redland librdf minor version number} \usage{ librdf_version_minor_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Return the Redland librdf minor version number } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/rasqal_version_release.Rd0000644000176200001440000000077114156450613017467 0ustar liggesusers\name{rasqal_version_release} \alias{rasqal_version_release} \title{Rasqal release version number.} \usage{ rasqal_version_release ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Rasqal release version number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_node_from_uri_string.Rd0000644000176200001440000000143114156450611021337 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node_from_uri_string} \alias{librdf_new_node_from_uri_string} \title{Constructor - create a new librdf_node object from a URI string.} \usage{ librdf_new_node_from_uri_string ( world, string ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{string}{string representing a URI ("character")} } \value{ _p_librdf_node_s } \description{ Constructor - create a new librdf_node object from a URI string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_stream_end.Rd0000644000176200001440000000117414156450612016377 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_stream_end} \alias{librdf_stream_end} \title{Test if the stream has ended.} \usage{ librdf_stream_end ( stream, .copy ) } \arguments{ \item{stream}{librdf_stream object ("_p_librdf_stream_s")} \item{.copy}{NA} } \value{ integer } \description{ Test if the stream has ended. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_parse_string_into_model.Rd0000644000176200001440000000163114156450612022541 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_parse_string_into_model} \alias{librdf_parser_parse_string_into_model} \title{Parse a string of content into an librdf_model.} \usage{ librdf_parser_parse_string_into_model ( parser, string, base_uri, model, .copy ) } \arguments{ \item{parser}{the parser ("_p_librdf_parser_s")} \item{string}{the content to parse ("character")} \item{base_uri}{the base URI to use or NULL ("_p_librdf_uri_s")} \item{model}{the model to use ("_p_librdf_model_s")} \item{.copy}{NA} } \value{ integer } \description{ Parse a string of content into an librdf_model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_transaction_commit.Rd0000644000176200001440000000121714156450611021330 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_transaction_commit} \alias{librdf_model_transaction_commit} \title{Commit a transaction.} \usage{ librdf_model_transaction_commit ( model, .copy ) } \arguments{ \item{model}{the model object ("_p_librdf_model_s")} \item{.copy}{NA} } \value{ integer } \description{ Commit a transaction. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_context_remove_statements.Rd0000644000176200001440000000145514156450611022747 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_context_remove_statements} \alias{librdf_model_context_remove_statements} \title{Remove statements from a model with the given context.} \usage{ librdf_model_context_remove_statements ( model, context, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{context}{librdf_node context ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Remove statements from a model with the given context. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_add_statement.Rd0000644000176200001440000000132614156450611020250 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_add_statement} \alias{librdf_model_add_statement} \title{Add a statement to the model.} \usage{ librdf_model_add_statement ( model, statement, .copy ) } \arguments{ \item{model}{model object ("_p_librdf_model_s")} \item{statement}{statement object ("_p_librdf_statement_s")} \item{.copy}{NA} } \value{ integer } \description{ Add a statement to the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_serializer_serialize_stream_to_file.Rd0000644000176200001440000000165614156450612023557 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_serializer_serialize_stream_to_file} \alias{librdf_serializer_serialize_stream_to_file} \title{Write a librdf_stream to a file.} \usage{ librdf_serializer_serialize_stream_to_file ( serializer, name, base_uri, stream, .copy ) } \arguments{ \item{serializer}{the serializer ("_p_librdf_serializer_s")} \item{name}{filename to serialize to ("character")} \item{base_uri}{the base URI to use (or NULL) ("_p_librdf_uri_s")} \item{stream}{the librdf_stream stream to use ("_p_librdf_stream_s")} \item{.copy}{NA} } \value{ integer } \description{ Write a librdf_stream to a file. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/getTermType.Rd0000644000176200001440000000174214566231540015210 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Statement.R \name{getTermType} \alias{getTermType} \alias{getTermType,Statement,character-method} \title{Return the redland node type for the specified RDF term in a statement} \usage{ getTermType(.Object, term) \S4method{getTermType}{Statement,character}(.Object, term) } \arguments{ \item{.Object}{a Statement object} \item{term}{the RDF term for which the type will be returned} } \description{ After a Statement object has been created, this method can be used to determine the RDF type ("uri", "literal", "blank") that has been assigned to the specified RDF term, i.e. "subject", "predicate", "object". } \examples{ world <- new("World") subject <- new("Node", blank="_:myid1", world) predicate <- new("Node", uri="http://www.example.com/isa", world) object <- new("Node", literal="thing", world) stmt <- new("Statement", world, subject, predicate, object, world) termType <- getTermType(stmt, "predicate") } redland/man/librdf_parser_parse_into_model.Rd0000644000176200001440000000161314156450612021153 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_parse_into_model} \alias{librdf_parser_parse_into_model} \title{Parse a URI of content into an librdf_model.} \usage{ librdf_parser_parse_into_model ( parser, uri, inUriOrNull, model, .copy ) } \arguments{ \item{parser}{the parser ("_p_librdf_parser_s")} \item{uri}{the URI to read the content ("_p_librdf_uri_s")} \item{inUriOrNull}{the base URI to use or NULL ("_p_librdf_uri_s")} \item{model}{the model to use ("_p_librdf_model_s")} \item{.copy}{NA} } \value{ integer } \description{ Parse a URI of content into an librdf_model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_as_stream.Rd0000644000176200001440000000123714156450611017413 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_as_stream} \alias{librdf_model_as_stream} \title{List the model contents as a stream of statements.} \usage{ librdf_model_as_stream ( model ) } \arguments{ \item{model}{the model object ("_p_librdf_model_s")} } \value{ _p_librdf_stream_s } \description{ List the model contents as a stream of statements. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_add_statements.Rd0000644000176200001440000000140514156450611020431 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_add_statements} \alias{librdf_model_add_statements} \title{Add a stream of statements to the model.} \usage{ librdf_model_add_statements ( model, statement_stream, .copy ) } \arguments{ \item{model}{model object ("_p_librdf_model_s")} \item{statement_stream}{stream of statements to use ("_p_librdf_stream_s")} \item{.copy}{NA} } \value{ integer } \description{ Add a stream of statements to the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/freeStorage.Rd0000644000176200001440000000155214566231540015204 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Storage.R \name{freeStorage} \alias{freeStorage} \alias{freeStorage,Storage-method} \title{Free memory used by a librdf storage object} \usage{ freeStorage(.Object) \S4method{freeStorage}{Storage}(.Object) } \arguments{ \item{.Object}{a Storage object to free memory for} } \description{ After this method is called, the Storage object is no longer usable and should be deleted \code{"rm(storage)"} and a new object created. } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") # At this point we would perform some operations using the storage object. # See '?redland' for a complete example. # When the Storage object is no longer needed, the resources it had allocated can be freed. status <- freeStorage(storage) rm(storage) } redland/man/librdf_model_find_statements_in_context.Rd0000644000176200001440000000164514156450611023061 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_find_statements_in_context} \alias{librdf_model_find_statements_in_context} \title{Search the model for matching statements in a given context.} \usage{ librdf_model_find_statements_in_context ( model, statement, inNodeOrNull ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{statement}{librdf_statement partial statement to find ("_p_librdf_statement_s")} \item{inNodeOrNull}{context librdf_node (or NULL) ("_p_librdf_node_s")} } \value{ _p_librdf_stream_s } \description{ Search the model for matching statements in a given context. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_version_major_get.Rd0000644000176200001440000000100414156450613020030 0ustar liggesusers\name{raptor_version_major_get} \alias{raptor_version_major_get} \title{Get Raptor library major version} \usage{ raptor_version_major_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Get Raptor library major version. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_version_major.Rd0000644000176200001440000000076014156450613017201 0ustar liggesusers\name{raptor_version_major} \alias{raptor_version_major} \title{Raptor library major version} \usage{ raptor_version_major ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Raptor library major version. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_statement_is_complete.Rd0000644000176200001440000000133314156450612020642 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_is_complete} \alias{librdf_statement_is_complete} \title{Check if statement is a complete and legal RDF triple.} \usage{ librdf_statement_is_complete ( statement, .copy ) } \arguments{ \item{statement}{librdf_statement object ("_p_librdf_statement_s")} \item{.copy}{NA} } \value{ integer } \description{ Check if statement is a complete and legal RDF triple. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Node-class.Rd0000644000176200001440000000270514566244056014735 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Node.R \docType{class} \encoding{UTF-8} \name{Node-class} \alias{Node-class} \alias{Node} \title{A Redland Node, used to store one node in an RDF triple statement.} \description{ A Node represents a RDF Resource, Property, Literal or an RDF blank Node. } \section{Slots}{ \describe{ \item{\code{librdf_node}}{A redland node object} }} \section{Methods}{ \itemize{ \code{\link{Node-initialize}}: Initialize a Node object. \code{\link{getNodeType}}: Determine the node type and return as a string. \code{\link{getNodeValue}}: Determine the node type and return as a string. \code{\link{getBlankNodeId}}: Get the value of the node as a string. } } \examples{ world <- new("World") # a blank node is created with a unique identifier generated by librdf node <- new("Node", world) # a blank node is created with a unique identifier generated by librdf node <- new("Node", world, blank=NULL) # a blank node is created with the user specified identifier, i.e. "_:id1" node <- new("Node", world, blank="someid") # a node type of 'literal' is created node <- new("Node", world, literal="A Node Value") # a Node type of 'resource' is created node <- new("Node", world, uri="http://www.example.com") # Create a literal node, specifying a language encoding node <- new("Node", world, literal="Gérard de La Martinière", language="fr") } \seealso{ \code{\link{redland}}: redland package } \keyword{classes} redland/man/librdf_iterator_get_object.Rd0000644000176200001440000000125214156450611020270 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_iterator_get_object} \alias{librdf_iterator_get_object} \title{Get the current object from the iterator.} \usage{ librdf_iterator_get_object ( iterator ) } \arguments{ \item{iterator}{the librdf_iterator object ("_p_librdf_iterator_s")} } \value{ _p_librdf_node_s } \description{ Get the current object from the iterator. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_serializer_serialize_stream_to_string.Rd0000644000176200001440000000154414156450612024142 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_serializer_serialize_stream_to_string} \alias{librdf_serializer_serialize_stream_to_string} \title{Write a librdf_stream to a string.} \usage{ librdf_serializer_serialize_stream_to_string ( serializer, base_uri, stream ) } \arguments{ \item{serializer}{the serializer ("_p_librdf_serializer_s")} \item{base_uri}{the base URI to use (or NULL) ("_p_librdf_uri_s")} \item{stream}{the librdf_stream stream to use ("_p_librdf_stream_s")} } \value{ character } \description{ Write a librdf_stream to a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_get_binding_value.Rd0000644000176200001440000000150114156450612022723 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_get_binding_value} \alias{librdf_query_results_get_binding_value} \title{Get one binding value for the current result.} \usage{ librdf_query_results_get_binding_value ( query_results, offset ) } \arguments{ \item{query_results}{librdf_query_results query results ("_p_librdf_query_results")} \item{offset}{offset of binding name into array of known names ("integer")} } \value{ _p_librdf_node_s } \description{ Get one binding value for the current result. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_arc.Rd0000644000176200001440000000157014156450611017041 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_arc} \alias{librdf_model_get_arc} \title{Return one arc (predicate) of an arc in an RDF graph given source (subject) and target (object).} \usage{ librdf_model_get_arc ( model, source, target ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{source}{librdf_node source ("_p_librdf_node_s")} \item{target}{librdf_node target ("_p_librdf_node_s")} } \value{ _p_librdf_node_s } \description{ Return one arc (predicate) of an arc in an RDF graph given source (subject) and target (object). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_get_binding_name.Rd0000644000176200001440000000145514156450612022537 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_get_binding_name} \alias{librdf_query_results_get_binding_name} \title{Get binding name for the current result.} \usage{ librdf_query_results_get_binding_name ( query_results, offset ) } \arguments{ \item{query_results}{librdf_query_results query results ("_p_librdf_query_results")} \item{offset}{offset of binding name into array of known names ("integer")} } \value{ character } \description{ Get binding name for the current result. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_transaction_rollback.Rd0000644000176200001440000000123114156450611021625 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_transaction_rollback} \alias{librdf_model_transaction_rollback} \title{Rollback a transaction.} \usage{ librdf_model_transaction_rollback ( model, .copy ) } \arguments{ \item{model}{the model object ("_p_librdf_model_s")} \item{.copy}{NA} } \value{ integer } \description{ Rollback a transaction. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_is_graph.Rd0000644000176200001440000000134214156450612021055 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_is_graph} \alias{librdf_query_results_is_graph} \title{Test if librdf_query_results is RDF graph format.} \usage{ librdf_query_results_is_graph ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results object ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Test if librdf_query_results is RDF graph format. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_context_as_stream.Rd0000644000176200001440000000135014156450611021153 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_context_as_stream} \alias{librdf_model_context_as_stream} \title{List all statements in a model context.} \usage{ librdf_model_context_as_stream ( model, context ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{context}{librdf_node context ("_p_librdf_node_s")} } \value{ _p_librdf_stream_s } \description{ List all statements in a model context. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_log_message_level.Rd0000644000176200001440000000122514156450611017726 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_log_message_level} \alias{librdf_log_message_level} \title{Retrieve severity of log message.} \usage{ librdf_log_message_level ( message, .copy ) } \arguments{ \item{message}{log message ("_p_librdf_log_message")} \item{.copy}{NA} } \value{ integer } \description{ Retrieve severity of log message. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_literal_value_is_wf_xml.Rd0000644000176200001440000000132714156450611023020 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_literal_value_is_wf_xml} \alias{librdf_node_get_literal_value_is_wf_xml} \title{Get the XML well-formness property of the node.} \usage{ librdf_node_get_literal_value_is_wf_xml ( node, .copy ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Get the XML well-formness property of the node. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_is_bindings.Rd0000644000176200001440000000137314156450612021555 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_is_bindings} \alias{librdf_query_results_is_bindings} \title{Test if librdf_query_results is variable bindings format.} \usage{ librdf_query_results_is_bindings ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results object ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Test if librdf_query_results is variable bindings format. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_copyright_string.Rd0000644000176200001440000000112514156450611017647 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_copyright_string} \alias{librdf_copyright_string} \title{Copyright string (multiple lines).} \usage{ librdf_copyright_string ( .copy ) } \arguments{ \item{.copy}{NA} } \value{ character } \description{ Copyright string (multiple lines). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_load.Rd0000644000176200001440000000171614156450611016356 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_load} \alias{librdf_model_load} \title{Load content from a URI into the model.} \usage{ librdf_model_load ( model, uri, name, mime_type, type_uri, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{uri}{the URI to read the content ("_p_librdf_uri_s")} \item{name}{the name of the parser (or NULL) ("character")} \item{mime_type}{the MIME type of the syntax (NULL if not used) ("character")} \item{type_uri}{URI identifying the syntax (NULL if not used) ("_p_librdf_uri_s")} \item{.copy}{NA} } \value{ integer } \description{ Load content from a URI into the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_locator_column.Rd0000644000176200001440000000106614156450613017344 0ustar liggesusers\name{raptor_locator_column} \alias{raptor_locator_column} \title{Get column number from locator} \usage{ raptor_locator_column ( locator, .copy ) } \arguments{ \item{locator}{raptor locator ("_p_raptor_locator")} \item{.copy}{logical} } \value{ integer } \description{ Get column number from locator } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_free_query.Rd0000644000176200001440000000116514156450611016423 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_query} \alias{librdf_free_query} \title{Destructor - destroy a librdf_query object.} \usage{ librdf_free_query ( query ) } \arguments{ \item{query}{librdf_query object ("_p_librdf_query")} } \value{ void } \description{ Destructor - destroy a librdf_query object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_uri_compare.Rd0000644000176200001440000000140214156450612016555 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_uri_compare} \alias{librdf_uri_compare} \title{Compare two librdf_uri objects lexicographically.} \usage{ librdf_uri_compare ( first_uri, second_uri, .copy ) } \arguments{ \item{first_uri}{librdf_uri object 1 or NULL ("_p_librdf_uri_s")} \item{second_uri}{librdf_uri object 2 or NULL ("_p_librdf_uri_s")} \item{.copy}{NA} } \value{ integer } \description{ Compare two librdf_uri objects lexicographically. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_context_remove_statement.Rd0000644000176200001440000000155414156450611022564 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_context_remove_statement} \alias{librdf_model_context_remove_statement} \title{Remove a statement from a model in a context.} \usage{ librdf_model_context_remove_statement ( model, context, statement, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{context}{librdf_node context ("_p_librdf_node_s")} \item{statement}{librdf_statement statement ("_p_librdf_statement_s")} \item{.copy}{NA} } \value{ integer } \description{ Remove a statement from a model in a context. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/getNodeValue.Rd0000644000176200001440000000164414566231540015322 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Node.R \encoding{UTF-8} \name{getNodeValue} \alias{getNodeValue} \alias{getNodeValue,Node-method} \title{Get the value of the node as a string} \usage{ getNodeValue(.Object) \S4method{getNodeValue}{Node}(.Object) } \arguments{ \item{.Object}{a Node object} } \value{ a string representation of the Node's value } \description{ Get the value of the node as a string } \details{ The value of the node is returned as a string. If the node type is 'blank', then the blank node identifier is returned. If the node type is 'literal', then the literal value is returned with the form "string@language, e.g. "¡Hola, amigo! ¿Cómo estás?"@es". If the node type is 'uri' then the value is returned as a string. } \examples{ world <- new("World") node <- new("Node", world, literal="¡Hola, amigo! ¿Cómo estás?", language="es") value <- getNodeValue(node) } redland/man/librdf_parser_get_namespaces_seen_count.Rd0000644000176200001440000000134414156450612023031 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_get_namespaces_seen_count} \alias{librdf_parser_get_namespaces_seen_count} \title{Get the number of namespaces seen during parsing} \usage{ librdf_parser_get_namespaces_seen_count ( parser, .copy ) } \arguments{ \item{parser}{librdf_parser object ("_p_librdf_parser_s")} \item{.copy}{NA} } \value{ integer } \description{ Get the number of namespaces seen during parsing } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_locator_uri.Rd0000644000176200001440000000077614156450613016655 0ustar liggesusers\name{raptor_locator_uri} \alias{raptor_locator_uri} \title{Get URI from locator.} \usage{ raptor_locator_uri ( locator ) } \arguments{ \item{locator}{raptor locator ("_p_raptor_locator")} } \value{ character } \description{ Get URI from locator. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_parse_counted_string_as_stream.Rd0000644000176200001440000000172714156450612024115 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_parse_counted_string_as_stream} \alias{librdf_parser_parse_counted_string_as_stream} \title{Parse a counted string of content to a librdf_stream of statements.} \usage{ librdf_parser_parse_counted_string_as_stream ( parser, string, length, base_uri ) } \arguments{ \item{parser}{the parser ("_p_librdf_parser_s")} \item{string}{the string to parse ("character")} \item{length}{length of the string content (must be >0) ("integer")} \item{base_uri}{the base URI to use or NULL ("_p_librdf_uri_s")} } \value{ _p_librdf_stream_s } \description{ Parse a counted string of content to a librdf_stream of statements. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_add.Rd0000644000176200001440000000163414156450611016166 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_add} \alias{librdf_model_add} \title{Create and add a new statement about a resource to the model.} \usage{ librdf_model_add ( model, subject, predicate, object, .copy ) } \arguments{ \item{model}{model object ("_p_librdf_model_s")} \item{subject}{librdf_node of subject ("_p_librdf_node_s")} \item{predicate}{librdf_node of predicate ("_p_librdf_node_s")} \item{object}{librdf_node of object (literal or resource) ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Create and add a new statement about a resource to the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_contains_context.Rd0000644000176200001440000000133514156450611021016 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_contains_context} \alias{librdf_model_contains_context} \title{Check for a context in the model.} \usage{ librdf_model_contains_context ( model, context, .copy ) } \arguments{ \item{model}{the model object ("_p_librdf_model_s")} \item{context}{the contest ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Check for a context in the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_version_string.Rd0000644000176200001440000000111514156450612017324 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_version_string} \alias{librdf_version_string} \title{Library full version as a string.} \usage{ librdf_version_string ( .copy ) } \arguments{ \item{.copy}{NA} } \value{ character } \description{ Library full version as a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_uri_from_filename.Rd0000644000176200001440000000140314156450611020603 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_uri_from_filename} \alias{librdf_new_uri_from_filename} \title{Constructor - create a new librdf_uri object from a filename.} \usage{ librdf_new_uri_from_filename ( world, filename ) } \arguments{ \item{world}{Redland librdf_world object ("_p_librdf_world_s")} \item{filename}{filename ("character")} } \value{ _p_librdf_uri_s } \description{ Constructor - create a new librdf_uri object from a filename. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/getQueryResultsLimit.Rd0000644000176200001440000000077614566231540017133 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Query.R \name{getQueryResultLimit} \alias{getQueryResultLimit} \alias{getQueryResultLimit,Query-method} \title{Get the query result limit} \usage{ getQueryResultLimit(.Object) \S4method{getQueryResultLimit}{Query}(.Object) } \arguments{ \item{.Object}{a Query object} } \value{ the query result limit. If a limit is set then the value will be >= 0. If the value is < 0, no limit is set } \description{ Get the query result limit } redland/man/librdf_free_query_results.Rd0000644000176200001440000000127514156450611020206 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_query_results} \alias{librdf_free_query_results} \title{Destructor - destroy a librdf_query_results object.} \usage{ librdf_free_query_results ( query_results ) } \arguments{ \item{query_results}{librdf_query_results object ("_p_librdf_query_results")} } \value{ void } \description{ Destructor - destroy a librdf_query_results object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_storage.Rd0000644000176200001440000000157014156450611016572 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_storage} \alias{librdf_new_storage} \title{Constructor - create a new librdf_storage object.} \usage{ librdf_new_storage ( world, storage_name, name, options_string ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{storage_name}{the storage factory name ("character")} \item{name}{an identifier for the storage ("character")} \item{options_string}{options to initialise storage ("character")} } \value{ _p_librdf_storage_s } \description{ Constructor - create a new librdf_storage object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_log_message_facility.Rd0000644000176200001440000000126614156450611020430 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_log_message_facility} \alias{librdf_log_message_facility} \title{Retrieve facility that generated the message.} \usage{ librdf_log_message_facility ( message, .copy ) } \arguments{ \item{message}{log message ("_p_librdf_log_message")} \item{.copy}{NA} } \value{ integer } \description{ Retrieve facility that generated the message. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/mergeNamespace_roclet.Rd0000644000176200001440000000304314566231540017217 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/mergeNamespace_roclet.R \name{mergeNamespace_roclet} \alias{mergeNamespace_roclet} \title{A custom Roxygen roclet that adds Redland RDF functions to NAMESPACE file generated by Roxygen.} \usage{ mergeNamespace_roclet(x, ...) } \arguments{ \item{x}{a roclet} \item{...}{additional parameters} } \description{ The redland package uses the SWIG (Simplified Wrapper and Interface Generator) to create the bindings between the Redland RDF C/C++ libraries and R. SWIG creates a NAMESPACE file that contains the function names for the librdf wrapper that it creates, but as of swig 3.0.2 this NAMESPACE file is incorrect and will also be overwritten by Roxygen when 'roxygenize()' or 'devtools:document()' is called, as the wrapper R code doesn't contain Roxygen export annotations used by Roxygen to build the namespace file. To allow for building a NAMESPACE file from all programs in the redland package, this roclet determines the set of wrapper R functions and adds these to the Roxygen generated NAMESPACE file that contains all names from the native R code in the redland package. } \details{ The following line must be present in the DESCRIPTION file for this roclet to be called automatically when 'roxygen2::roxygenize()' or 'devtools::document()' is called: Roxygen: list(roclets = c("collate", "rd", "namespace", "mergeNamespace_roclet")) The 'namespace' roclet must always run before the 'mergeNamespace' roclet. } \examples{ \dontrun{ roxygen2::roxygenize() devtools::document() } } redland/man/getNodeType.Rd0000644000176200001440000000122214566231540015157 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Node.R \name{getNodeType} \alias{getNodeType} \alias{getNodeType,Node-method} \title{Determine the node type and return as a string} \usage{ getNodeType(.Object) \S4method{getNodeType}{Node}(.Object) } \arguments{ \item{.Object}{a Node object} } \value{ a character vector containing the Node type } \description{ A Node has a type that is assigned at initialization and can have one of the following values: 'resource', 'literal', 'blank' and 'unknown'. } \examples{ world <- new("World") node <- new("Node", world, uri="http://www.example.com") nodeType <- getNodeType(node) } redland/man/librdf_stream_get_object.Rd0000644000176200001440000000125114156450612017732 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_stream_get_object} \alias{librdf_stream_get_object} \title{Get the current librdf_statement in the stream.} \usage{ librdf_stream_get_object ( stream ) } \arguments{ \item{stream}{librdf_stream object ("_p_librdf_stream_s")} } \value{ _p_librdf_statement_s } \description{ Get the current librdf_statement in the stream. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_execute.Rd0000644000176200001440000000126414156450612017145 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_execute} \alias{librdf_query_execute} \title{Run the query on a model.} \usage{ librdf_query_execute ( query, model ) } \arguments{ \item{query}{librdf_query object ("_p_librdf_query")} \item{model}{model to operate query on ("_p_librdf_model_s")} } \value{ _p_librdf_query_results } \description{ Run the query on a model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_source.Rd0000644000176200001440000000156214156450611017575 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_source} \alias{librdf_model_get_source} \title{Return one source (subject) of arc in an RDF graph given arc (predicate) and target (object).} \usage{ librdf_model_get_source ( model, arc, target ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{arc}{librdf_node arc ("_p_librdf_node_s")} \item{target}{librdf_node target ("_p_librdf_node_s")} } \value{ _p_librdf_node_s } \description{ Return one source (subject) of arc in an RDF graph given arc (predicate) and target (object). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/freeSerializer.Rd0000644000176200001440000000205714566231540015712 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Serializer.R \name{freeSerializer} \alias{freeSerializer} \alias{freeSerializer,Serializer-method} \title{Free memory used by a librdf serializer.} \usage{ freeSerializer(.Object) \S4method{freeSerializer}{Serializer}(.Object) } \arguments{ \item{.Object}{a Serializer object} } \description{ Free memory used by a librdf serializer. } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") filePath <- system.file("extdata/example.rdf", package="redland") parser <- new("Parser", world) parseFileIntoModel(parser, world, filePath, model) # Creat the default "rdfxml" serizlizer serializer <- new("Serializer", world) # At this point, some operations would be performed with the Serializer object. # See '?Serializer' for a complete example. # When the serializer object is no longer needed, the resources it had allocated can be freed. freeSerializer(serializer) rm(serializer) } redland/man/librdf_new_model_from_model.Rd0000644000176200001440000000132614156450611020430 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_model_from_model} \alias{librdf_new_model_from_model} \title{Copy constructor - create a new librdf_model from an existing one.} \usage{ librdf_new_model_from_model ( model ) } \arguments{ \item{model}{the existing librdf_model ("_p_librdf_model_s")} } \value{ _p_librdf_model_s } \description{ Copy constructor - create a new librdf_model from an existing one. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/QueryResults-class.Rd0000644000176200001440000000134014566244056016531 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/QueryResults.R \docType{class} \name{QueryResults-class} \alias{QueryResults-class} \alias{QueryResults} \title{A Redland QueryResults object is used to inspect query results from a Query object.} \description{ The QueryResults object contains the RDF statements that were returned from a query on an RDF model. } \section{Slots}{ \describe{ \item{\code{librdf_query_results}}{A redland query object} }} \section{Methods}{ \itemize{ \code{\link{QueryResults-initialize}}: Initialize a QueryResults object. \code{\link{freeQueryResults}}: Free memory used by a librdf query result. } } \seealso{ \code{\link{redland}}: redland package } \keyword{classes} redland/man/librdf_parser_get_accept_header.Rd0000644000176200001440000000122614156450612021236 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_get_accept_header} \alias{librdf_parser_get_accept_header} \title{Get an HTTP Accept value for the parser.} \usage{ librdf_parser_get_accept_header ( parser ) } \arguments{ \item{parser}{parser ("_p_librdf_parser_s")} } \value{ character } \description{ Get an HTTP Accept value for the parser. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Storage-class.Rd0000644000176200001440000000140214566244056015445 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Storage.R \docType{class} \name{Storage-class} \alias{Storage-class} \alias{Storage} \title{A Redland Storage object} \description{ A Redland Storage object } \section{Slots}{ \describe{ \item{\code{librdf_storage}}{A redland storage object} \item{\code{type}}{the storage type to create, i.e. "hashes", "mysql", "postgresql", ...} }} \section{Methods}{ \itemize{ \code{\link{Storage-initialize}}: Initialize a Storage object \code{\link{freeStorage}}: Free memory used by a librdf storage object } } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") } \seealso{ \code{\link{redland}}: redland package } \keyword{classes} redland/man/writeResults.Rd0000644000176200001440000000377514566231540015463 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Query.R \name{writeResults} \alias{writeResults} \alias{writeResults,Query-method} \title{Write query results to a file.} \usage{ writeResults(.Object, model, ...) \S4method{writeResults}{Query}( .Object, model, file, mimeType = "application/x-turtle", format_uri = NULL, base_uri = NULL ) } \arguments{ \item{.Object}{a Query object} \item{model}{a Model object} \item{...}{additional parameters} \item{file}{a string specifying the output file} \item{mimeType}{a string specifying the mimeType of the output file. Currently supported values are "application/x-turtle", "text/plain", "application/json", "text/html"} \item{format_uri}{(not currently used)} \item{base_uri}{(not currently used)} } \description{ Write query results to a file. } \details{ After this method is called, the Query object is no longer usable and should be deleted \code{"rm(query)"} and a new object created. } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") stmt <- new("Statement", world=world, subject="https://orcid.org/0000-0002-2192-403X", predicate="http://www.w3.org/ns/prov#Agent", object="slaughter", objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") status <- addStatement(model, stmt) queryString <- paste("PREFIX orcid: ", "PREFIX dataone: ", "PREFIX prov: ", "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) # Return all results as a string tf <- tempfile() writeResults(query, model, file=tf, mimeType="application/x-turtle") # When the query object is no longer needed, the resources it had allocated can be freed. freeQuery(query) rm(query) } redland/man/librdf_parser_parse_as_stream.Rd0000644000176200001440000000146114156450612021001 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_parse_as_stream} \alias{librdf_parser_parse_as_stream} \title{Parse a URI to a librdf_stream of statements.} \usage{ librdf_parser_parse_as_stream ( parser, uri, inUriorNull ) } \arguments{ \item{parser}{the parser ("_p_librdf_parser_s")} \item{uri}{the URI to read ("_p_librdf_uri_s")} \item{inUriorNull}{the base URI to use or NULL ("_p_librdf_uri_s")} } \value{ _p_librdf_stream_s } \description{ Parse a URI to a librdf_stream of statements. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_uri_from_uri.Rd0000644000176200001440000000134014156450611017622 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_uri_from_uri} \alias{librdf_new_uri_from_uri} \title{Copy constructor - create a new librdf_uri object from an existing librdf_uri object.} \usage{ librdf_new_uri_from_uri ( uri ) } \arguments{ \item{uri}{librdf_uri object ("_p_librdf_uri_s")} } \value{ _p_librdf_uri_s } \description{ Copy constructor - create a new librdf_uri object from an existing librdf_uri object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_hash_from_array_of_strings.Rd0000644000176200001440000000160014156450611022521 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_hash_from_array_of_strings} \alias{librdf_new_hash_from_array_of_strings} \title{Constructor - create a new librdf_hash object from an array of strings.} \usage{ librdf_new_hash_from_array_of_strings ( world, name, string ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{hash name ("character")} \item{string}{address of the start of the array of char* pointers ("character")} } \value{ _p_librdf_hash_s } \description{ Constructor - create a new librdf_hash object from an array of strings. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_locator_file.Rd0000644000176200001440000000101514156450613016760 0ustar liggesusers\name{raptor_locator_file} \alias{raptor_locator_file} \title{Get file name from locator.} \usage{ raptor_locator_file ( locator ) } \arguments{ \item{locator}{raptor locator ("_p_raptor_locator")} } \value{ character } \description{ Get file name from locator. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_node_from_literal.Rd0000644000176200001440000000164614156450611020616 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node_from_literal} \alias{librdf_new_node_from_literal} \title{Constructor - create a new literal librdf_node object.} \usage{ librdf_new_node_from_literal ( world, string, inStrOrNull, is_wf_xml ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{string}{literal UTF-8 encoded string value ("character")} \item{inStrOrNull}{literal XML language (or NULL, empty string) ("character")} \item{is_wf_xml}{non 0 if literal is XML ("integer")} } \value{ _p_librdf_node_s } \description{ Constructor - create a new literal librdf_node object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_remove_statement.Rd0000644000176200001440000000136614156450611021021 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_remove_statement} \alias{librdf_model_remove_statement} \title{Remove a known statement from the model.} \usage{ librdf_model_remove_statement ( model, statement, .copy ) } \arguments{ \item{model}{the model object ("_p_librdf_model_s")} \item{statement}{the statement ("_p_librdf_statement_s")} \item{.copy}{NA} } \value{ integer } \description{ Remove a known statement from the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/serializeToFile.Rd0000644000176200001440000000153614566231540016032 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Serializer.R \name{serializeToFile} \alias{serializeToFile} \alias{serializeToFile,Serializer,World,Model,character-method} \title{Serialize a model to a file.} \usage{ serializeToFile(.Object, world, model, filePath, ...) \S4method{serializeToFile}{Serializer,World,Model,character}(.Object, world, model, filePath, baseUri = as.character(NA)) } \arguments{ \item{.Object}{a Serializer object} \item{world}{a World object} \item{model}{a Model object} \item{filePath}{a file path that the serialized model will be written to} \item{...}{Additional parameters} \item{baseUri}{a base URI to use for the serialization} } \value{ an integer containing the return status where non zero indicates an error occurred during serialization } \description{ Serialize a model to a file. } redland/man/librdf_query_get_offset.Rd0000644000176200001440000000125014156450612017623 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_get_offset} \alias{librdf_query_get_offset} \title{Get the query-specified offset on results.} \usage{ librdf_query_get_offset ( query, .copy ) } \arguments{ \item{query}{librdf_query query object ("_p_librdf_query")} \item{.copy}{NA} } \value{ integer } \description{ Get the query-specified offset on results. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/World-class.Rd0000644000176200001440000000134414566244056015135 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/World.R \docType{class} \name{World-class} \alias{World-class} \alias{World} \title{A Redland World object, used to initialize the Redland RDF library.} \description{ A World object is the top level object in the Redland RDF library implementation, so it contains all other objects needed to process RDF Models. } \section{Slots}{ \describe{ \item{\code{librdf_world}}{A redland world object} }} \section{Methods}{ \itemize{ \code{\link{World-initialize}}: Initialize a World object \code{\link{freeWorld}}: Free memory used by a librdf world object } } \examples{ world <- new("World") } \seealso{ \code{\link{redland}}: redland package } \keyword{classes} redland/man/librdf_new_statement_from_statement.Rd0000644000176200001440000000172114156450611022237 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_statement_from_statement} \alias{librdf_new_statement_from_statement} \title{Copy constructor - create a new librdf_statement from an existing librdf_statement. Creates a deep copy - changes to original statement nodes are not reflected in the copy.} \usage{ librdf_new_statement_from_statement ( statement ) } \arguments{ \item{statement}{librdf_statement to copy ("_p_librdf_statement_s")} } \value{ _p_librdf_statement_s } \description{ Copy constructor - create a new librdf_statement from an existing librdf_statement. Creates a deep copy - changes to original statement nodes are not reflected in the copy. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_uri_to_string.Rd0000644000176200001440000000113514156450612017142 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_uri_to_string} \alias{librdf_uri_to_string} \title{Format the URI as a string.} \usage{ librdf_uri_to_string ( uri ) } \arguments{ \item{uri}{librdf_uri object ("_p_librdf_uri_s")} } \value{ character } \description{ Format the URI as a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_query_from_query.Rd0000644000176200001440000000136314156450611020543 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_query_from_query} \alias{librdf_new_query_from_query} \title{Copy constructor - create a new librdf_query object from an existing one} \usage{ librdf_new_query_from_query ( old_query ) } \arguments{ \item{old_query}{the existing query librdf_query to use ("_p_librdf_query")} } \value{ _p_librdf_query } \description{ Copy constructor - create a new librdf_query object from an existing one } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_find_statements.Rd0000644000176200001440000000136114156450611020622 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_find_statements} \alias{librdf_model_find_statements} \title{Find matching statements in the model.} \usage{ librdf_model_find_statements ( model, statement ) } \arguments{ \item{model}{the model object ("_p_librdf_model_s")} \item{statement}{the partial statement to match ("_p_librdf_statement_s")} } \value{ _p_librdf_stream_s } \description{ Find matching statements in the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/rasqal_version_string_get.Rd0000644000176200001440000000101214156450613020201 0ustar liggesusers\name{rasqal_version_string_get} \alias{rasqal_version_string_get} \title{Get the Rasqal version as a string} \usage{ rasqal_version_string_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Get the Rasqal version as a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_to_string2.Rd0000644000176200001440000000174414156450612021361 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_to_string2} \alias{librdf_query_results_to_string2} \title{Turn a query results into a string.} \usage{ librdf_query_results_to_string2 ( query_results, name, mime_type, format_uri, base_uri ) } \arguments{ \item{query_results}{librdf_query_results object ("_p_librdf_query_results")} \item{name}{format name ("character")} \item{mime_type}{format mime type (or NULL) ("character")} \item{format_uri}{URI of syntax to format to (or NULL) ("_p_librdf_uri_s")} \item{base_uri}{Base URI of output formatted syntax (or NULL) ("_p_librdf_uri_s")} } \value{ character } \description{ Turn a query results into a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_world.Rd0000644000176200001440000000106414156450611016253 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_world} \alias{librdf_new_world} \title{Create a new Redland execution environment.} \usage{ librdf_new_world ( ) } \value{ _p_librdf_world_s } \description{ Create a new Redland execution environment. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_serializer_serialize_model_to_file.Rd0000644000176200001440000000170014156450612023352 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_serializer_serialize_model_to_file} \alias{librdf_serializer_serialize_model_to_file} \title{Write a serialized librdf_model to a file.} \usage{ librdf_serializer_serialize_model_to_file ( serializer, name, inUriOrNull, model, .copy ) } \arguments{ \item{serializer}{the serializer ("_p_librdf_serializer_s")} \item{name}{filename to serialize to ("character")} \item{inUriOrNull}{the base URI to use (or NULL) ("_p_librdf_uri_s")} \item{model}{the librdf_model model to use ("_p_librdf_model_s")} \item{.copy}{NA} } \value{ integer } \description{ Write a serialized librdf_model to a file. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_finished.Rd0000644000176200001440000000133314156450612021052 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_finished} \alias{librdf_query_results_finished} \title{Find out if binding results are exhausted.} \usage{ librdf_query_results_finished ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results query results ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Find out if binding results are exhausted. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/rasqal_version_decimal_get.Rd0000644000176200001440000000103614156450613020277 0ustar liggesusers\name{rasqal_version_decimal_get} \alias{rasqal_version_decimal_get} \title{Get the Rasqal version as a decimal number.} \usage{ rasqal_version_decimal_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Get the Rasqal version as a decimal number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_literal_value_as_latin1.Rd0000644000176200001440000000132114156450611022676 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_literal_value_as_latin1} \alias{librdf_node_get_literal_value_as_latin1} \title{Get the string literal value of the node as ISO Latin-1.} \usage{ librdf_node_get_literal_value_as_latin1 ( node ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} } \value{ character } \description{ Get the string literal value of the node as ISO Latin-1. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_guess_name2.Rd0000644000176200001440000000157114156450612020043 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_guess_name2} \alias{librdf_parser_guess_name2} \title{Get a parser name for content with type or identifier} \usage{ librdf_parser_guess_name2 ( world, mime_type, buffer, identifier ) } \arguments{ \item{world}{librdf_world object ("_p_librdf_world_s")} \item{mime_type}{MIME type of syntax or NULL ("character")} \item{buffer}{content buffer or NULL ("character")} \item{identifier}{content identifier or NULL ("character")} } \value{ character } \description{ Get a parser name for content with type or identifier } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/setNameSpace.Rd0000644000176200001440000000122014566231540015276 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Serializer.R \name{setNameSpace} \alias{setNameSpace} \alias{setNameSpace,Serializer,World,character,character-method} \title{Set a namespace for the serializer.} \usage{ setNameSpace(.Object, world, namespace, prefix) \S4method{setNameSpace}{Serializer,World,character,character}(.Object, world, namespace, prefix) } \arguments{ \item{.Object}{a Serializer object} \item{world}{a World object} \item{namespace}{the namespace to add to the serializer} \item{prefix}{the namespace prefix to associate with the namespace} } \description{ Set a namespace for the serializer. } redland/man/librdf_query_results_next.Rd0000644000176200001440000000125314156450612020240 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_next} \alias{librdf_query_results_next} \title{Move to the next result.} \usage{ librdf_query_results_next ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results query results ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Move to the next result. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_is_literal.Rd0000644000176200001440000000116614156450612017413 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_is_literal} \alias{librdf_node_is_literal} \title{Check node is a literal.} \usage{ librdf_node_is_literal ( node, .copy ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Check node is a literal. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/freeModel.Rd0000644000176200001440000000160214566231540014634 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Model.R \name{freeModel} \alias{freeModel} \alias{freeModel,Model-method} \title{Free memory used by a librdf model.} \usage{ freeModel(.Object) \S4method{freeModel}{Model}(.Object) } \arguments{ \item{.Object}{a Model object} } \description{ Free memory used by a librdf model. } \details{ After this method is called, the Model object is no longer usable and should be deleted \code{"rm(model)"} and a new object created. } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") # At this point, some operations would be performed with the model. # See '?redland' for a complete example. # When the Model object is no longer needed, the resources it has allocated can be freed. freeModel(model) rm(model) } redland/man/librdf_iterator_get_context.Rd0000644000176200001440000000130714156450611020507 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_iterator_get_context} \alias{librdf_iterator_get_context} \title{Get the context of the current object on the iterator.} \usage{ librdf_iterator_get_context ( iterator ) } \arguments{ \item{iterator}{the librdf_iterator object ("_p_librdf_iterator_s")} } \value{ _p_librdf_node_s } \description{ Get the context of the current object on the iterator. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/serializeToCharacter.Rd0000644000176200001440000000136114566231540017043 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Serializer.R \name{serializeToCharacter} \alias{serializeToCharacter} \alias{serializeToCharacter,Serializer,World,Model-method} \title{Serialize a model to a character vector.} \usage{ serializeToCharacter(.Object, world, model, ...) \S4method{serializeToCharacter}{Serializer,World,Model}(.Object, world, model, baseUri = as.character(NA)) } \arguments{ \item{.Object}{a Serializer object} \item{world}{a World object} \item{model}{a Model object} \item{...}{Additional parameters} \item{baseUri}{a URI to prepend to relative URIs in the document} } \value{ a character vector containing the serialized model } \description{ Serialize a model to a character vector. } redland/man/librdf_node_is_blank.Rd0000644000176200001440000000117214156450612017043 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_is_blank} \alias{librdf_node_is_blank} \title{Check node is a blank nodeID.} \usage{ librdf_node_is_blank ( node, .copy ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Check node is a blank nodeID. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_arcs_in.Rd0000644000176200001440000000136414156450611017713 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_arcs_in} \alias{librdf_model_get_arcs_in} \title{Return the properties pointing to the given resource.} \usage{ librdf_model_get_arcs_in ( model, node ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{node}{librdf_node resource node ("_p_librdf_node_s")} } \value{ _p_librdf_iterator_s } \description{ Return the properties pointing to the given resource. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_locator_line.Rd0000644000176200001440000000105514156450613016774 0ustar liggesusers\name{raptor_locator_line} \alias{raptor_locator_line} \title{Get line number from locator.} \usage{ raptor_locator_line ( locator, .copy ) } \arguments{ \item{locator}{raptor locator ("_p_raptor_locator")} \item{.copy}{logical} } \value{ integer } \description{ Get line number from locator. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_statement.Rd0000644000176200001440000000124014156450611017124 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_statement} \alias{librdf_new_statement} \title{Constructor - create a new empty librdf_statement.} \usage{ librdf_new_statement ( world ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} } \value{ _p_librdf_statement_s } \description{ Constructor - create a new empty librdf_statement. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_type.Rd0000644000176200001440000000116214156450611017077 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_type} \alias{librdf_node_get_type} \title{Get the type of the node.} \usage{ librdf_node_get_type ( node, .copy ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Get the type of the node. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/freeStatement.Rd0000644000176200001440000000222114566231540015536 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Statement.R \name{freeStatement} \alias{freeStatement} \alias{freeStatement,Statement-method} \title{Free memory used by a librdf statement} \usage{ freeStatement(.Object) \S4method{freeStatement}{Statement}(.Object) } \arguments{ \item{.Object}{a Statement object} } \description{ Free memory used by a librdf statement } \details{ After this method is called, the Statement object is no longer usable and should be deleted \code{"rm(statement)"} and a new object created. This method frees all resources for the statement, as well as each node in the statement. } \examples{ world <- new("World") stmt <- new("Statement", world, subject="http://www.example.com/myevent", predicate="http://example.com/occurredAt", object="Tue Feb 17 14:05:13 PST 2015") # At this point, some operations would be performed with the Statement. # See '?redland' for a complete example. # When the Statement object is no longer needed, the resources it had allocated can be freed. freeStatement(stmt) rm(stmt) } redland/man/Model-initialize.Rd0000644000176200001440000000101614566231540016130 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Model.R \name{initialize,Model-method} \alias{initialize,Model-method} \alias{Model-initialize} \title{Constructor for a Model object.} \usage{ \S4method{initialize}{Model}(.Object, world, storage, options) } \arguments{ \item{.Object}{a Node object} \item{world}{a World object} \item{storage}{a Storage object} \item{options}{extra options for model initialization} } \value{ the World object } \description{ Constructor for a Model object. } redland/man/librdf_parser_parse_counted_string_into_model.Rd0000644000176200001440000000200514156450612024256 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_parse_counted_string_into_model} \alias{librdf_parser_parse_counted_string_into_model} \title{Parse a counted string of content into an librdf_model.} \usage{ librdf_parser_parse_counted_string_into_model ( parser, string, length, base_uri, model, .copy ) } \arguments{ \item{parser}{the parser ("_p_librdf_parser_s")} \item{string}{the content to parse ("character")} \item{length}{length of content (must be >0) ("integer")} \item{base_uri}{the base URI to use or NULL ("_p_librdf_uri_s")} \item{model}{the model to use ("_p_librdf_model_s")} \item{.copy}{NA} } \value{ integer } \description{ Parse a counted string of content into an librdf_model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_get_count.Rd0000644000176200001440000000130614156450612021250 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_get_count} \alias{librdf_query_results_get_count} \title{Get number of bindings so far.} \usage{ librdf_query_results_get_count ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results query results ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Get number of bindings so far. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_free_model.Rd0000644000176200001440000000120114156450611016345 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_model} \alias{librdf_free_model} \title{Destructor - Destroy a librdf_model object.} \usage{ librdf_free_model ( model ) } \arguments{ \item{model}{librdf_model model to destroy ("_p_librdf_model_s")} } \value{ void } \description{ Destructor - Destroy a librdf_model object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_get_namespaces_seen_uri.Rd0000644000176200001440000000141114156450612022473 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_get_namespaces_seen_uri} \alias{librdf_parser_get_namespaces_seen_uri} \title{Get the uri of namespaces seen during parsing} \usage{ librdf_parser_get_namespaces_seen_uri ( parser, offset ) } \arguments{ \item{parser}{librdf_parser object ("_p_librdf_parser_s")} \item{offset}{index into list of namespaces ("integer")} } \value{ _p_librdf_uri_s } \description{ Get the uri of namespaces seen during parsing } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/executeQuery.Rd0000644000176200001440000000100214566231540015414 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Query.R \name{executeQuery} \alias{executeQuery} \alias{executeQuery,Query-method} \title{Execute a query} \usage{ executeQuery(.Object, model) \S4method{executeQuery}{Query}(.Object, model) } \arguments{ \item{.Object}{a Query object} \item{model}{a Model object containing the statements to query} } \value{ a QueryResults object } \description{ The initialize query is executed and the result is returned as a QueryResult object } redland/man/librdf_model_get_sources.Rd0000644000176200001440000000157514156450611017764 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_sources} \alias{librdf_model_get_sources} \title{Return the sources (subjects) of arc in an RDF graph given arc (predicate) and target (object).} \usage{ librdf_model_get_sources ( model, arc, target ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{arc}{librdf_node arc ("_p_librdf_node_s")} \item{target}{librdf_node target ("_p_librdf_node_s")} } \value{ _p_librdf_iterator_s } \description{ Return the sources (subjects) of arc in an RDF graph given arc (predicate) and target (object). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_arcs.Rd0000644000176200001440000000160314156450611017221 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_arcs} \alias{librdf_model_get_arcs} \title{Return the arcs (predicates) of an arc in an RDF graph given source (subject) and target (object).} \usage{ librdf_model_get_arcs ( model, source, target ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{source}{librdf_node source ("_p_librdf_node_s")} \item{target}{librdf_node target ("_p_librdf_node_s")} } \value{ _p_librdf_iterator_s } \description{ Return the arcs (predicates) of an arc in an RDF graph given source (subject) and target (object). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_internal_test_error.Rd0000644000176200001440000000116414156450611020340 0ustar liggesusers\name{librdf_internal_test_error} \alias{librdf_internal_test_error} \title{For internal testing, not part of public API} \usage{ librdf_internal_test_error ( world ) } \arguments{ \item{world}{librdf_world object ("_p_librdf_world_s")} } \value{ void } \description{ This funciton is for internal testing of the Redland software and is not part of the public API. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/QueryResults-initialize.Rd0000644000176200001440000000137114566231540017563 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/QueryResults.R \name{initialize,QueryResults-method} \alias{initialize,QueryResults-method} \alias{QueryResults-initialize} \title{Initialize the QueryResults object.} \usage{ \S4method{initialize}{QueryResults}(.Object, results) } \arguments{ \item{.Object}{the QueryResults object.} \item{results}{a librdf query result} } \value{ the QueryResults object } \description{ The QueryResults object is initialized with the librdf query result from return value of \code{'Query.execute()'}. } \details{ A QueryResults object is returned by the \code{Query.executeQuery()} method, so typically a user does not initialize a QueryResult object by calling \code{new("QueryResult", ...)} } redland/man/librdf_free_serializer.Rd0000644000176200001440000000123414156450611017424 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_serializer} \alias{librdf_free_serializer} \title{Destructor - destroys a librdf_serializer object.} \usage{ librdf_free_serializer ( serializer ) } \arguments{ \item{serializer}{the serializer ("_p_librdf_serializer_s")} } \value{ void } \description{ Destructor - destroys a librdf_serializer object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Model-class.Rd0000644000176200001440000000234314566244056015106 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Model.R \docType{class} \name{Model-class} \alias{Model-class} \alias{Model} \title{A Redland Model object} \description{ A Model object is used to store the statements (triples) of an RDF model. } \details{ A Model may be created manually by creating \code{\link{Statement}} and adding them to the Model using \code{\link{addStatement}}, or a Model may be read in from a previously saved file using \code{\link{parseFileIntoModel}}. Once a Model is created, it can be queried using \code{\link{Query}}. } \section{Slots}{ \describe{ \item{\code{librdf_model}}{A redland model object} }} \section{Methods}{ \itemize{ \code{\link{Model-initialize}}: Initialize a Model object \code{\link{addStatement}}: Add a Statement object to the Model \code{\link{freeModel}}: Free memory used by a librdf model object } } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") } \seealso{ View examples of creating models by viewing the \code{'redland_overview'} vignette: \code{'vignette("redland_overview")'} \code{\link{redland}}: redland package } \keyword{classes} redland/man/rasqal_version_release_get.Rd0000644000176200001440000000102414156450613020316 0ustar liggesusers\name{rasqal_version_release_get} \alias{rasqal_version_release_get} \title{Get the Rasqal release version number.} \usage{ rasqal_version_release_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Get the Rasqal release version number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_free_statement.Rd0000644000176200001440000000121514156450611017256 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_statement} \alias{librdf_free_statement} \title{Destructor - destroy a librdf_statement.} \usage{ librdf_free_statement ( statement ) } \arguments{ \item{statement}{librdf_statement object ("_p_librdf_statement_s")} } \value{ void } \description{ Destructor - destroy a librdf_statement. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/freeQuery.Rd0000644000176200001440000000276414566231540014713 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Query.R \name{freeQuery} \alias{freeQuery} \alias{freeQuery,Query-method} \title{Free memory used by a librdf query} \usage{ freeQuery(.Object) \S4method{freeQuery}{Query}(.Object) } \arguments{ \item{.Object}{a Query object} } \description{ Free memory used by a librdf query } \details{ After this method is called, the Query object is no longer usable and should be deleted \code{"rm(query)"} and a new object created. } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") stmt <- new("Statement", world=world, subject="https://orcid.org/0000-0002-2192-403X", predicate="http://www.w3.org/ns/prov#Agent", object="slaughter", objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") status <- addStatement(model, stmt) queryString <- paste("PREFIX orcid: ", "PREFIX dataone: ", "PREFIX prov: ", "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) # Return all results as a string results <- getResults(query, model, "rdfxml") # When the query object is no longer needed, the resources it had allocated can be freed. freeQuery(query) rm(query) } redland/man/librdf_new_node_from_blank_identifier.Rd0000644000176200001440000000156314156450611022451 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node_from_blank_identifier} \alias{librdf_new_node_from_blank_identifier} \title{Constructor - create a new blank node librdf_node object from a blank node identifier.} \usage{ librdf_new_node_from_blank_identifier ( world, inStrOrNull ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{inStrOrNull}{UTF-8 encoded blank node identifier or NULL ("character")} } \value{ _p_librdf_node_s } \description{ Constructor - create a new blank node librdf_node object from a blank node identifier. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_digest_init.Rd0000644000176200001440000000115614156450611016557 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_digest_init} \alias{librdf_digest_init} \title{(Re)initialise the librdf_digest object.} \usage{ librdf_digest_init ( digest ) } \arguments{ \item{digest}{the digest ("_p_librdf_digest_s")} } \value{ void } \description{ (Re)initialise the librdf_digest object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_get_binding_value_by_name.Rd0000644000176200001440000000152414156450612024422 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_get_binding_value_by_name} \alias{librdf_query_results_get_binding_value_by_name} \title{Get one binding value for a given name in the current result.} \usage{ librdf_query_results_get_binding_value_by_name ( query_results, name ) } \arguments{ \item{query_results}{librdf_query_results query results ("_p_librdf_query_results")} \item{name}{variable name ("character")} } \value{ _p_librdf_node_s } \description{ Get one binding value for a given name in the current result. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_version_string_get.Rd0000644000176200001440000000104414156450612020164 0ustar liggesusers\name{librdf_version_string_get} \alias{librdf_version_string_get} \title{Return the Redland librdf version as a string.} \usage{ librdf_version_string_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ character } \description{ Return the Redland librdf version as a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_arcs_out.Rd0000644000176200001440000000137314156450611020114 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_arcs_out} \alias{librdf_model_get_arcs_out} \title{Return the properties pointing from the given resource.} \usage{ librdf_model_get_arcs_out ( model, node ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{node}{librdf_node resource node ("_p_librdf_node_s")} } \value{ _p_librdf_iterator_s } \description{ Return the properties pointing from the given resource. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Node-initialize.Rd0000644000176200001440000000301314566231540015754 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Node.R \name{initialize,Node-method} \alias{initialize,Node-method} \alias{Node-initialize} \title{Initialize a Node object.} \usage{ \S4method{initialize}{Node}(.Object, world, literal, uri, blank, datatype_uri, language) } \arguments{ \item{.Object}{the Node object to be initialized} \item{world}{a World object} \item{literal}{a literal character value to be assigned to the node} \item{uri}{a uri character value to be assigned to the node} \item{blank}{a blank node identifier to be assigned to the node} \item{datatype_uri}{a uri used to specify the datatype of a literal node, i.e. "http://www.w3.org/2001/XMLSchema#string"} \item{language}{a character value specifying the RDF language tag (excluding the "@" symbol), i.e. "fr"} } \value{ the Node object } \description{ A Node has an associated type corresponding to the RDF component that it is representing. The list of possible types is "resource", "literal" or "blank". } \details{ The url=' and 'literal=' arguments determine which type of Node is created. The Node type affects how the Node is processed in serialization, for example a Node created with 'node1 <- new("Node", literal="http://www.example.com")' is processed differently that a Node created with 'node1 <- new("Node", url="http://www.example.com")', with the former being processed as an RDF literal and the latter processed as an RDF resource. } \note{ Refer to https://www.w3.org/TR/rdf11-concepts information on language tags. } redland/man/raptor_version_string.Rd0000644000176200001440000000077014156450613017400 0ustar liggesusers\name{raptor_version_string} \alias{raptor_version_string} \title{Raptor library version string.} \usage{ raptor_version_string ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ character } \description{ Raptor library version string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_statement_get_predicate.Rd0000644000176200001440000000123414156450612021136 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_get_predicate} \alias{librdf_statement_get_predicate} \title{Get the statement predicate.} \usage{ librdf_statement_get_predicate ( statement ) } \arguments{ \item{statement}{librdf_statement object ("_p_librdf_statement_s")} } \value{ _p_librdf_node_s } \description{ Get the statement predicate. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_query_execute.Rd0000644000176200001440000000132214156450611020317 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_query_execute} \alias{librdf_model_query_execute} \title{Execute a query against the model.} \usage{ librdf_model_query_execute ( model, query ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{query}{librdf_query object ("_p_librdf_query")} } \value{ _p_librdf_query_results } \description{ Execute a query against the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_version_minor_get.Rd0000644000176200001440000000100514156450613020045 0ustar liggesusers\name{raptor_version_minor_get} \alias{raptor_version_minor_get} \title{Get Raptor library minor version.} \usage{ raptor_version_minor_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Get Raptor library minor version. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/length-SWIGArray-method.Rd0000644000176200001440000000036414156450611017240 0ustar liggesusers\docType{methods} \name{length,SWIGArray-method} \alias{length,SWIGArray-method} \title{Return length of a SWIGArray} \usage{ \S4method{length}{SWIGArray}(x) } \arguments{ \item{x}{the SWIGArray} } \description{ Return length of a SWIGArray } redland/man/freeParser.Rd0000644000176200001440000000211314566231540015026 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Parser.R \name{freeParser} \alias{freeParser} \alias{freeParser,Parser-method} \title{Free memory used by a librdf parser} \usage{ freeParser(.Object) \S4method{freeParser}{Parser}(.Object) } \arguments{ \item{.Object}{a Node object} } \description{ Free memory used by a librdf parser } \details{ After freeNode is called, the Node object is no longer usable and should be deleted \code{"rm(nodeName)"} and a new object created. } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") parser <- new("Parser", world) filePath <- system.file("extdata/example.rdf", package="redland") parseFileIntoModel(parser, world, filePath, model) # At this point, some operations would be performed with the Model that has been populated # with the parser. # See '?redland' for a complete example. # When the parser object is no longer needed, the resources it had allocated can be freed. freeParser(parser) rm(parser) } redland/man/librdf_free_hash.Rd0000644000176200001440000000114714156450611016201 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_hash} \alias{librdf_free_hash} \title{Destructor - destroy a librdf_hash object.} \usage{ librdf_free_hash ( hash ) } \arguments{ \item{hash}{hash object ("_p_librdf_hash_s")} } \value{ void } \description{ Destructor - destroy a librdf_hash object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Query-class.Rd0000644000176200001440000000466614566244056015165 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Query.R \docType{class} \name{Query-class} \alias{Query-class} \alias{Query} \title{Query an RDF model} \description{ The Query class is used to execute a query on a Model object using the default query language SPARQL. For more information, please refer to \url{https://librdf.org/rasqal/} for details on supported query languages. } \details{ A Query is executed using the executeQuery method, which returns a QueryResults object that can be iterated over the query solution sequence. } \section{Slots}{ \describe{ \item{\code{librdf_query}}{A redland query object} \item{\code{librdf_world}}{A redland world object} }} \section{Methods}{ \itemize{ \code{\link{Query-initialize}}: Initialize a Query object. \code{\link{executeQuery}}: Execute a query. \code{\link{setQueryResultLimit}}: Set limit on returned query results. \code{\link{getQueryResultLimit}}: Get the query result limit. \code{\link{getResults}}: Return all query results. \code{\link{writeResults}}: Write query results to a file. \code{\link{freeParser}}: Free memory used by a librdf query. } } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") stmt <- new("Statement", world=world, subject="https://cn.dataone.org/cn/v1/resolve/urn:uuid:274a0c5c-3082-4562-bbd3-2b1288768cac", predicate="http://www.w3.org/ns/prov#hadPlan", object="https://cn.dataone.org/cn/v1/resolve/urn:uuid:01305f45-f22b-40c8-8d27-00357d01e4a5") status <- addStatement(model, stmt) stmt <- new("Statement", world=world, subject="https://orcid.org/0000-0002-2192-403X", predicate="http://www.w3.org/ns/prov#Agent", object="slaughter", objectType="literal", datatype_uri="http://www.w3.org/2001/XMLSchema#string") status <- addStatement(model, stmt) queryString <- paste("PREFIX orcid: ", "PREFIX dataone: ", "PREFIX prov: ", "SELECT ?a ?c WHERE { ?a prov:Agent ?c . }", sep=" ") query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) # Return all results as a string results <- getResults(query, model, "rdfxml") } \references{ www.example.com } \seealso{ \code{\link{redland}}: redland package } \keyword{classes} redland/man/rasqal_version_decimal.Rd0000644000176200001440000000100314156450613017432 0ustar liggesusers\name{rasqal_version_decimal} \alias{rasqal_version_decimal} \title{Rasqal version as a decimal number.} \usage{ rasqal_version_decimal ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Rasqal version as a decimal number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_is_boolean.Rd0000644000176200001440000000134414156450612021375 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_is_boolean} \alias{librdf_query_results_is_boolean} \title{Test if librdf_query_results is boolean format.} \usage{ librdf_query_results_is_boolean ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results object ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Test if librdf_query_results is boolean format. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_to_string.Rd0000644000176200001440000000175414156450611017451 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_to_string} \alias{librdf_model_to_string} \title{Write serialized model to a string.} \usage{ librdf_model_to_string ( model, uri, name, mime_type, inUriOrNull ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{uri}{base URI to use in serializing (or NULL if not used) ("_p_librdf_uri_s")} \item{name}{the name of the serializer (or NULL for default) ("character")} \item{mime_type}{the MIME type of the syntax (NULL if not used) ("character")} \item{inUriOrNull}{URI identifying the syntax (NULL if not used) ("_p_librdf_uri_s")} } \value{ character } \description{ Write serialized model to a string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_node_from_typed_literal.Rd0000644000176200001440000000173614156450611022023 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node_from_typed_literal} \alias{librdf_new_node_from_typed_literal} \title{Constructor - create a new typed literal librdf_node object.} \usage{ librdf_new_node_from_typed_literal ( world, string, inStrOrNull, inUriOrNull ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{string}{literal UTF-8 encoded string value ("character")} \item{inStrOrNull}{literal XML language (or NULL, empty string) ("character")} \item{inUriOrNull}{URI of typed literal datatype or NULL ("_p_librdf_uri_s")} } \value{ _p_librdf_node_s } \description{ Constructor - create a new typed literal librdf_node object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_get_bindings_count.Rd0000644000176200001440000000140514156450612023125 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_get_bindings_count} \alias{librdf_query_results_get_bindings_count} \title{Get the number of bound variables in the result.} \usage{ librdf_query_results_get_bindings_count ( query_results, .copy ) } \arguments{ \item{query_results}{librdf_query_results query results ("_p_librdf_query_results")} \item{.copy}{NA} } \value{ integer } \description{ Get the number of bound variables in the result. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/rasqal_version_minor_get.Rd0000644000176200001440000000101214156450613020017 0ustar liggesusers\name{rasqal_version_minor_get} \alias{rasqal_version_minor_get} \title{Get the Rasqal minor version number.} \usage{ rasqal_version_minor_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Get the Rasqal minor version number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/redland.Rd0000644000176200001440000001036714566231540014353 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/redland-package.R \docType{package} \name{redland} \alias{redland} \title{Create, query and write RDF graphs.} \description{ The R package \emph{redland} provides methods to create, query and write information stored in the Resource Description Framework (RDF). This package is implemented as R scripts that provide an R interface (aka "wrapper") to the Redland RDF C libraries. Documentation for the redland R package classes and functions are available from the standard R help facility, for example, \code{'help("Node-class")'}, \code{'?getNodeType'}, etc. An overview of the redland R package is available with the R command: \code{'vignette("redland_overview")'}. The Redland C library functions are described at \url{https://librdf.org/docs/api/index.html}. An introduction to RDF can be found at \url{https://www.w3.org/TR/rdf-primer/}. } \details{ The redland R package classes and the corresponding Redland C library types are shown in the following table: \tabular{llll}{ \strong{Concept}\tab \strong{Redland C type}\tab \strong{redland R class}\tab \strong{Purpose}\cr Resource / Literal\tab librdf_node\tab \linkS4class{Node}\tab RDF Model & Syntax nodes\cr Statement / Triple\tab librdf_statement\tab \linkS4class{Statement}\tab RDF Model & Syntax arcs (statements, triples)\cr Model\tab librdf_model\tab \linkS4class{Model}\tab Set of Statements usually held in one Storage.\cr Node\tab librdf_node\tab \linkS4class{Node}\tab The subject, predicate or object of a Statement\cr Storage\tab librdf_storage\tab \linkS4class{Storage}\tab Storage for Models either persistent or in-memory.\cr Parser\tab librdf_parser\tab \linkS4class{Parser}\tab Syntax parsers delivering Stream of Statements or writing to a Model\cr Query\tab librdf_query\tab \linkS4class{Query}\tab Querying of an Model delivering a QueryResults\cr QueryResults\tab librdf_query_results\tab \linkS4class{QueryResults}\tab Results of applying an Query to a Model giving either variable bindings with Node values or Stream of Statements\cr Serializer\tab librdf_serializer\tab \linkS4class{Serializer}\tab Serializes a Model into a syntax such as RDF/XML\cr World\tab librdf_world\tab \linkS4class{World}\tab RDF wrapper class handling Redland startup/shutdown\cr } } \note{ In order to communicate with the Redland RDF C libraries, the redland R package uses an interface layer that is created with the software package \emph{Simplified Wrapper and Interface Generator} (\href{https://github.com/swig/swig}{SWIG}). The relationship between the redland R package and the Redland C libraries is: User script -> redland R package -> SWIG R interface -> Redland C libraries -> RDF data It is recommended that the redland package R classes be used to interact with RDF, as these higher level classes take care of many of the the details of communicating with the Redland C libraries. However, all of the lower level R interface functions generated by SWIG are made available by the redland package. These interface functions usually have names beginning with \code{'librdf_'}, \code{'rasqal_'} or \code{'raptor_'} and are usually the same name as the underlying C library function. Documentation for the R SWIG interface functions can be found via R help i.e. \code{'?librdf_iterator'}. } \examples{ # This example creates the necessary R objects to hold an RDF model and reads # in a file that contains RDF/XML statements. This model is then queried for # and the query results inspected. world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") filePath <- system.file("extdata/example.rdf", package="redland") parser <- new("Parser", world) parseFileIntoModel(parser, world, filePath, model) queryString <- paste("PREFIX dc: ", "SELECT ?a ?c WHERE { ?a dc:description ?c . }", sep="") query <- new("Query", world, queryString, base_uri=NULL, query_language="sparql", query_uri=NULL) results <- getResults(query, model, "rdfxml") # When the query object is no longer needed, the resources it had allocated can be freed. freeQuery(query) rm(query) } \author{ Matthew B. Jones (NCEAS) and Peter Slaughter (NCEAS) } redland/man/parseFileIntoModel.Rd0000644000176200001440000000272114566231540016462 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Parser.R \name{parseFileIntoModel} \alias{parseFileIntoModel} \alias{parseFileIntoModel,Parser,World,character,Model-method} \title{Parse the contents of a file into a model} \usage{ parseFileIntoModel(.Object, world, filePath, model, ...) \S4method{parseFileIntoModel}{Parser,World,character,Model}(.Object, world, filePath, model, baseUri = as.character(NA)) } \arguments{ \item{.Object}{a Parser object} \item{world}{a World object} \item{filePath}{a file that contains the RDF content} \item{model}{a Model object to parse the RDF content into} \item{...}{(Additional parameters)} \item{baseUri}{a base URI (i.e. XML base) to apply to the model} } \description{ The contents of a the specified file are read and parsed into the initialized Parser object } \details{ The parser factory name specified during initialization determines how the content is parsed, for example, if 'rdfxml' was specified during parser initialization, then the parser expects RDF/XML content as specified in the W3C recommendation (http://www.we3.org/TR/REC-rdf-syntax) } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") # Create the default "rdfxml" parser parser <- new("Parser", world) filePath <- system.file("extdata/example.rdf", package="redland") parseFileIntoModel(parser, world, filePath, model) } redland/man/freeWorld.Rd0000644000176200001440000000135714566231540014672 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/World.R \name{freeWorld} \alias{freeWorld} \alias{freeWorld,World-method} \title{Free memory used by a librdf world object} \usage{ freeWorld(.Object) \S4method{freeWorld}{World}(.Object) } \arguments{ \item{.Object}{a World object} } \description{ Free memory used by a librdf world object } \details{ After this method is called, the World object is no longer usable and should be deleted \code{"rm(world)"} and a new object created. } \examples{ world <- new("World") # At this point we would perform some operations using the world object. # When the world object is no longer needed, we can free the resources it has allocated. result <- freeWorld(world) rm(world) } redland/man/librdf_stream_next.Rd0000644000176200001440000000124514156450612016606 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_stream_next} \alias{librdf_stream_next} \title{Move to the next librdf_statement in the stream.} \usage{ librdf_stream_next ( stream, .copy ) } \arguments{ \item{stream}{librdf_stream object ("_p_librdf_stream_s")} \item{.copy}{NA} } \value{ integer } \description{ Move to the next librdf_statement in the stream. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_hash_to_string.Rd0000644000176200001440000000142614156450611017270 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_hash_to_string} \alias{librdf_hash_to_string} \title{Format the hash as a string, suitable for parsing by librdf_hash_from_string.} \usage{ librdf_hash_to_string ( hash, filter ) } \arguments{ \item{hash}{librdf_hash object ("_p_librdf_hash_s")} \item{filter}{NULL terminated list of keys to ignore ("_p_p_char")} } \value{ character } \description{ Format the hash as a string, suitable for parsing by librdf_hash_from_string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_get_namespaces_seen_prefix.Rd0000644000176200001440000000142214156450612023173 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_get_namespaces_seen_prefix} \alias{librdf_parser_get_namespaces_seen_prefix} \title{Get the prefix of namespaces seen during parsing} \usage{ librdf_parser_get_namespaces_seen_prefix ( parser, offset ) } \arguments{ \item{parser}{librdf_parser object ("_p_librdf_parser_s")} \item{offset}{index into list of namespaces ("integer")} } \value{ character } \description{ Get the prefix of namespaces seen during parsing } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/rasqal_version_major_get.Rd0000644000176200001440000000100414156450613020004 0ustar liggesusers\name{rasqal_version_major_get} \alias{rasqal_version_major_get} \title{Get Rasqal major version number.} \usage{ rasqal_version_major_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Get Rasqal major version number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_free_uri.Rd0000644000176200001440000000114514156450611016053 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_uri} \alias{librdf_free_uri} \title{Destructor - destroy a librdf_uri object.} \usage{ librdf_free_uri ( uri ) } \arguments{ \item{uri}{librdf_uri object ("_p_librdf_uri_s")} } \value{ void } \description{ Destructor - destroy a librdf_uri object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_version_minor.Rd0000644000176200001440000000076114156450613017216 0ustar liggesusers\name{raptor_version_minor} \alias{raptor_version_minor} \title{Raptor library minor version.} \usage{ raptor_version_minor ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Raptor library minor version. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_node_from_node.Rd0000644000176200001440000000136714156450611020107 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node_from_node} \alias{librdf_new_node_from_node} \title{Copy constructor - create a new librdf_node object from an existing librdf_node object.} \usage{ librdf_new_node_from_node ( node ) } \arguments{ \item{node}{librdf_node object to copy ("_p_librdf_node_s")} } \value{ _p_librdf_node_s } \description{ Copy constructor - create a new librdf_node object from an existing librdf_node object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_world_set_logger.Rd0000644000176200001440000000142714156450612017620 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_world_set_logger} \alias{librdf_world_set_logger} \title{Set the world log handling function.} \usage{ librdf_world_set_logger ( world, user_data, log_handler ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{user_data}{user data to pass to function ("_p_void")} \item{log_handler}{pointer to the function ("_p_librdf_log_func")} } \value{ void } \description{ Set the world log handling function. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_version_string_get.Rd0000644000176200001440000000101514156450613020230 0ustar liggesusers\name{raptor_version_string_get} \alias{raptor_version_string_get} \title{Get Raptor library version string.} \usage{ raptor_version_string_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ character } \description{ Get Raptor library version string. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_query_results_to_file2.Rd0000644000176200001440000000176214156450612020772 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_query_results_to_file2} \alias{librdf_query_results_to_file2} \title{Write a query results to a file.} \usage{ librdf_query_results_to_file2 ( query_results, name, mime_type, format_uri, base_uri, .copy ) } \arguments{ \item{query_results}{librdf_query_results object ("_p_librdf_query_results")} \item{name}{filename to write to ("character")} \item{mime_type}{mime type (or NULL) ("character")} \item{format_uri}{URI of syntax to format to (or NULL) ("_p_librdf_uri_s")} \item{base_uri}{Base URI of output formatted syntax (or NULL) ("_p_librdf_uri_s")} \item{.copy}{NA} } \value{ integer } \description{ Write a query results to a file. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_node_get_literal_value_datatype_uri.Rd0000644000176200001440000000133614156450611023523 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_node_get_literal_value_datatype_uri} \alias{librdf_node_get_literal_value_datatype_uri} \title{Get the typed literal datatype URI of the literal node.} \usage{ librdf_node_get_literal_value_datatype_uri ( node ) } \arguments{ \item{node}{the node object ("_p_librdf_node_s")} } \value{ _p_librdf_uri_s } \description{ Get the typed literal datatype URI of the literal node. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Parser-class.Rd0000644000176200001440000000200414566244056015274 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Parser.R \docType{class} \name{Parser-class} \alias{Parser-class} \alias{Parser} \title{An RDF Parser object} \description{ The Parser class provides methods to parse RDF content into a Redland RDF model. } \section{Slots}{ \describe{ \item{\code{librdf_parser}}{A redland parser object} }} \section{Methods}{ \itemize{ \code{\link{Parser-initialize}}: Initialize a Parser object. \code{\link{parseFileIntoModel}}: Parse the contents of a file into a model. \code{\link{freeParser}}: Free memory used by a librdf parser. } } \examples{ world <- new("World") storage <- new("Storage", world, "hashes", name="", options="hash-type='memory'") model <- new("Model", world, storage, options="") # Create the default "rdfxml" parser parser <- new("Parser", world) filePath <- system.file("extdata/example.rdf", package="redland") parseFileIntoModel(parser, world, filePath, model) } \seealso{ \code{\link{redland}}: redland package } \keyword{classes} redland/man/librdf_serializer_set_feature.Rd0000644000176200001440000000146214156450612021015 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_serializer_set_feature} \alias{librdf_serializer_set_feature} \title{Set the value of a serializer feature.} \usage{ librdf_serializer_set_feature ( serializer, feature, value, .copy ) } \arguments{ \item{serializer}{serializer object ("_p_librdf_serializer_s")} \item{feature}{URI of feature ("_p_librdf_uri_s")} \item{value}{value to set ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Set the value of a serializer feature. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_model.Rd0000644000176200001440000000146614156450611016232 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_model} \alias{librdf_new_model} \title{Constructor - create a new storage librdf_model object.} \usage{ librdf_new_model ( world, storage, options_string ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{storage}{librdf_storage to use ("_p_librdf_storage_s")} \item{options_string}{options to initialise model ("character")} } \value{ _p_librdf_model_s } \description{ Constructor - create a new storage librdf_model object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_storage_from_storage.Rd0000644000176200001440000000142314156450611021336 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_storage_from_storage} \alias{librdf_new_storage_from_storage} \title{Copy constructor - create a new librdf_storage object from an existing one} \usage{ librdf_new_storage_from_storage ( old_storage ) } \arguments{ \item{old_storage}{the existing storage librdf_storage to use ("_p_librdf_storage_s")} } \value{ _p_librdf_storage_s } \description{ Copy constructor - create a new librdf_storage object from an existing one } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_node_from_uri.Rd0000644000176200001440000000141414156450611017752 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node_from_uri} \alias{librdf_new_node_from_uri} \title{Constructor - create a new resource librdf_node object with a given URI.} \usage{ librdf_new_node_from_uri ( world, uri ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{uri}{librdf_uri object ("_p_librdf_uri_s")} } \value{ _p_librdf_node_s } \description{ Constructor - create a new resource librdf_node object with a given URI. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_statement_equals.Rd0000644000176200001440000000137014156450612017632 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_statement_equals} \alias{librdf_statement_equals} \title{Check if two statements are equal.} \usage{ librdf_statement_equals ( statement1, statement2, .copy ) } \arguments{ \item{statement1}{first librdf_statement ("_p_librdf_statement_s")} \item{statement2}{second librdf_statement ("_p_librdf_statement_s")} \item{.copy}{NA} } \value{ integer } \description{ Check if two statements are equal. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_node_from_uri_local_name.Rd0000644000176200001440000000162614156450611022131 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_node_from_uri_local_name} \alias{librdf_new_node_from_uri_local_name} \title{Constructor - create a new resource librdf_node object with a given URI and local name.} \usage{ librdf_new_node_from_uri_local_name ( world, uri, local_name ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{uri}{librdf_uri object ("_p_librdf_uri_s")} \item{local_name}{local name to append to URI ("character")} } \value{ _p_librdf_node_s } \description{ Constructor - create a new resource librdf_node object with a given URI and local name. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/Serializer-initialize.Rd0000644000176200001440000000132214566231540017201 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Serializer.R \name{initialize,Serializer-method} \alias{initialize,Serializer-method} \alias{Serializer-initialize} \title{Construct a Serializer object.} \usage{ \S4method{initialize}{Serializer}( .Object, world, name = "rdfxml", mimeType = "application/rdf+xml", typeUri = as.character(NA) ) } \arguments{ \item{.Object}{the Serializer object} \item{world}{a World object} \item{name}{name of a previously created serializer factory to use} \item{mimeType}{a mime type of the syntax of the model} \item{typeUri}{a URI for the syntax of the model} } \value{ the Serializer object } \description{ Construct a Serializer object. } redland/man/librdf_free_world.Rd0000644000176200001440000000122214156450611016377 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_world} \alias{librdf_free_world} \title{Terminate the library and frees all allocated resources.} \usage{ librdf_free_world ( world ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} } \value{ void } \description{ Terminate the library and frees all allocated resources. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_get_targets.Rd0000644000176200001440000000160314156450611017742 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_get_targets} \alias{librdf_model_get_targets} \title{Return the targets (objects) of an arc in an RDF graph given source (subject) and arc (predicate).} \usage{ librdf_model_get_targets ( model, source, arc ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{source}{librdf_node source ("_p_librdf_node_s")} \item{arc}{librdf_node arc ("_p_librdf_node_s")} } \value{ _p_librdf_iterator_s } \description{ Return the targets (objects) of an arc in an RDF graph given source (subject) and arc (predicate). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_model_add_typed_literal_statement.Rd0000644000176200001440000000214214156450611023166 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_add_typed_literal_statement} \alias{librdf_model_add_typed_literal_statement} \title{Create and add a new statement about a typed literal to the model.} \usage{ librdf_model_add_typed_literal_statement ( model, subject, predicate, string, inStrOrNull, inUriOrNull, .copy ) } \arguments{ \item{model}{model object ("_p_librdf_model_s")} \item{subject}{librdf_node of subject ("_p_librdf_node_s")} \item{predicate}{librdf_node of predicate ("_p_librdf_node_s")} \item{string}{string literal content ("character")} \item{inStrOrNull}{language of literal ("character")} \item{inUriOrNull}{datatype librdf_uri ("_p_librdf_uri_s")} \item{.copy}{NA} } \value{ integer } \description{ Create and add a new statement about a typed literal to the model. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_set_feature.Rd0000644000176200001440000000147014156450612020137 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_set_feature} \alias{librdf_parser_set_feature} \title{Set the value of a parser feature.} \usage{ librdf_parser_set_feature ( parser, feature, value, .copy ) } \arguments{ \item{parser}{librdf_parser object ("_p_librdf_parser_s")} \item{feature}{librdf_uri feature property ("_p_librdf_uri_s")} \item{value}{librdf_node feature property value ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Set the value of a parser feature. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_free_iterator.Rd0000644000176200001440000000122214156450611017101 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_free_iterator} \alias{librdf_free_iterator} \title{Destructor - destroy a librdf_iterator object.} \usage{ librdf_free_iterator ( s_arg1 ) } \arguments{ \item{s_arg1}{the librdf_iterator object ("_p_librdf_iterator_s")} } \value{ void } \description{ Destructor - destroy a librdf_iterator object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/raptor_version_decimal_get.Rd0000644000176200001440000000101714156450613020322 0ustar liggesusers\name{raptor_version_decimal_get} \alias{raptor_version_decimal_get} \title{Raptor version as a decimal number.} \usage{ raptor_version_decimal_get ( .copy ) } \arguments{ \item{.copy}{logical} } \value{ integer } \description{ Raptor version as a decimal number. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_parser.Rd0000644000176200001440000000164114156450611016421 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_parser} \alias{librdf_new_parser} \title{Constructor - create a new librdf_parser object.} \usage{ librdf_new_parser ( world, name, mime_type, type_uri ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{the parser factory name (or NULL or empty string if don't care) ("character")} \item{mime_type}{the MIME type of the syntax (NULL if not used) ("character")} \item{type_uri}{URI of syntax (NULL if not used) ("_p_librdf_uri_s")} } \value{ _p_librdf_parser_s } \description{ Constructor - create a new librdf_parser object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_parser_get_feature.Rd0000644000176200001440000000133114156450612020117 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_parser_get_feature} \alias{librdf_parser_get_feature} \title{Get the value of a parser feature.} \usage{ librdf_parser_get_feature ( parser, feature ) } \arguments{ \item{parser}{librdf_parser object ("_p_librdf_parser_s")} \item{feature}{librdf_Uuri feature property ("_p_librdf_uri_s")} } \value{ _p_librdf_node_s } \description{ Get the value of a parser feature. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_internal_test_warning.Rd0000644000176200001440000000116314156450611020653 0ustar liggesusers\name{librdf_internal_test_warning} \alias{librdf_internal_test_warning} \title{For internal testing, not part of public API} \usage{ librdf_internal_test_warning ( world ) } \arguments{ \item{world}{librdf_world ("_p_librdf_world_s")} } \value{ void } \description{ This funciton is for internal testing of the Redland software and is not part of the public API. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_new_query.Rd0000644000176200001440000000171314156450611016272 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_new_query} \alias{librdf_new_query} \title{Constructor - create a new librdf_query object.} \usage{ librdf_new_query ( world, name, uri, query_string, base_uri ) } \arguments{ \item{world}{redland world object ("_p_librdf_world_s")} \item{name}{the name identifying the query language ("character")} \item{uri}{the URI identifying the query language (or NULL) ("_p_librdf_uri_s")} \item{query_string}{the query string ("character")} \item{base_uri}{the base URI of the query string (or NULL) ("_p_librdf_uri_s")} } \value{ _p_librdf_query } \description{ Constructor - create a new librdf_query object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_iterator_end.Rd0000644000176200001440000000123014156450611016725 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_iterator_end} \alias{librdf_iterator_end} \title{Test if the iterator has finished.} \usage{ librdf_iterator_end ( iterator, .copy ) } \arguments{ \item{iterator}{the librdf_iterator object ("_p_librdf_iterator_s")} \item{.copy}{NA} } \value{ integer } \description{ Test if the iterator has finished. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_world_get_feature.Rd0000644000176200001440000000131714156450612017756 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_world_get_feature} \alias{librdf_world_get_feature} \title{Get the value of a world feature.} \usage{ librdf_world_get_feature ( world, feature ) } \arguments{ \item{world}{librdf_world object ("_p_librdf_world_s")} \item{feature}{librdf_uri feature property ("_p_librdf_uri_s")} } \value{ _p_librdf_node_s } \description{ Get the value of a world feature. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_short_copyright_string.Rd0000644000176200001440000000114714156450612021073 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_short_copyright_string} \alias{librdf_short_copyright_string} \title{Short copyright string (one line).} \usage{ librdf_short_copyright_string ( .copy ) } \arguments{ \item{.copy}{NA} } \value{ character } \description{ Short copyright string (one line). } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_log_message_code.Rd0000644000176200001440000000123214156450611017527 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_log_message_code} \alias{librdf_log_message_code} \title{Retrieve error code from log message.} \usage{ librdf_log_message_code ( message, .copy ) } \arguments{ \item{message}{log message ("_p_librdf_log_message")} \item{.copy}{NA} } \value{ integer } \description{ Retrieve error code from log message. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/sub-ExternalReference-method.Rd0000644000176200001440000000064114156450613020401 0ustar liggesusers\docType{methods} \name{[,ExternalReference-method} \alias{[,ExternalReference-method} \title{Subset a list of ExternalReferences} \usage{ \S4method{[}{ExternalReference}(x, i, j, ..., drop = TRUE) } \arguments{ \item{x}{a list of ExternalReferences} \item{i}{row subscript} \item{j}{column subscript} \item{...}{additional arguments} \item{drop}{a logical} } \description{ Subset a list of ExternalReferences } redland/man/librdf_model_has_arc_in.Rd0000644000176200001440000000151014156450611017515 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_model_has_arc_in} \alias{librdf_model_has_arc_in} \title{Check if a node has a given property pointing to it.} \usage{ librdf_model_has_arc_in ( model, node, property, .copy ) } \arguments{ \item{model}{librdf_model object ("_p_librdf_model_s")} \item{node}{librdf_node resource node ("_p_librdf_node_s")} \item{property}{librdf_node property node ("_p_librdf_node_s")} \item{.copy}{NA} } \value{ integer } \description{ Check if a node has a given property pointing to it. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_digest_to_string.Rd0000644000176200001440000000122414156450611017620 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_digest_to_string} \alias{librdf_digest_to_string} \title{Get a string representation of the digest object.} \usage{ librdf_digest_to_string ( digest ) } \arguments{ \item{digest}{the digest ("_p_librdf_digest_s")} } \value{ character } \description{ Get a string representation of the digest object. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/man/librdf_version_decimal.Rd0000644000176200001440000000114014156450612017412 0ustar liggesusers% Generated by redland-bindings R program "createLibrdfDocs.R": do not edit by hand \name{librdf_version_decimal} \alias{librdf_version_decimal} \title{Library full version as a decimal integer.} \usage{ librdf_version_decimal ( .copy ) } \arguments{ \item{.copy}{NA} } \value{ integer } \description{ Library full version as a decimal integer. } \references{ \url{https://librdf.org/docs/} } \seealso{ This R function is a wrapper function that directly calls the the Redland RDF C libraries. For more information about Redland RDF, view the online documentation indicated in the 'References' section. } redland/DESCRIPTION0000644000176200001440000000531315116210440013365 0ustar liggesusersPackage: redland Version: 1.0.17-19 Title: RDF Library Bindings in R Authors@R: c( person("Matthew B.", "Jones", role = c("aut","cre"), email = "jones@nceas.ucsb.edu", comment=c(ORCID = "0000-0003-0077-4738")), person("Peter", "Slaughter", role = "aut", email = "slaughter@nceas.ucsb.edu", comment=c(ORCID = "0000-0002-2192-403X")), person("Jeroen", "Ooms", role = c("aut"), email="jeroen@berkeley.edu", comment=c(ORCID = "0000-0002-4035-0289")), person("Carl", "Boettiger", role = "aut", email = "cboettig@gmail.com", comment=c(ORCID = "0000-0002-1642-628X")), person("Scott", "Chamberlain", role = "ctb", email = "myrmecocystus@gmail.com", comment=c(ORCID = "0000-0003-1444-9135")), person("David", "Beckett", role = c("cph")), person("University of Bristol", role = c("cph")), person("Regents of the University of California", role = c("cph")) ) Date: 2025-12-09 VignetteBuilder: knitr Description: Provides methods to parse, query and serialize information stored in the Resource Description Framework (RDF). RDF is described at . This package supports RDF by implementing an R interface to the Redland RDF C library, described at . In brief, RDF provides a structured graph consisting of Statements composed of Subject, Predicate, and Object Nodes. Depends: R (>= 3.1.1), methods Imports: roxygen2 Suggests: spelling, knitr, testthat, rmarkdown, stringi SystemRequirements: Mac OSX: redland (>= 1.0.14) ; Linux: librdf0 (>= 1.0.14), librdf0-dev (>= 1.0.14) Collate: 'redland.R' 'World.R' 'Node.R' 'Statement.R' 'Storage.R' 'Model.R' 'Parser.R' 'Query.R' 'QueryResults.R' 'Serializer.R' 'mergeNamespace_roclet.R' 'redland-package.R' 'util.R' License: Apache License 2.0 Copyright: See file (inst/)COPYRIGHTS. BugReports: https://github.com/ropensci/redland-bindings/issues RoxygenNote: 7.3.1 URL: https://github.com/ropensci/redland-bindings/tree/master/R/redland https://github.com/ropensci/redland-bindings/tree/master/R Encoding: UTF-8 Language: en-US NeedsCompilation: yes Packaged: 2025-12-09 21:59:51 UTC; jones Author: Matthew B. Jones [aut, cre] (ORCID: ), Peter Slaughter [aut] (ORCID: ), Jeroen Ooms [aut] (ORCID: ), Carl Boettiger [aut] (ORCID: ), Scott Chamberlain [ctb] (ORCID: ), David Beckett [cph], University of Bristol [cph], Regents of the University of California [cph] Maintainer: Matthew B. Jones Repository: CRAN Date/Publication: 2025-12-10 06:20:16 UTC