# 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')

