Methods

Redland

module RDF


This module initialises the Redland library and references all resources from it.


register a new class

Public Class Methods

librdf_digest_final(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_digest_final(int argc, VALUE *argv, VALUE self) {
  librdf_digest *arg1 = (librdf_digest *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_digest_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_digest *","librdf_digest_final", 1, argv[0] )); 
  }
  arg1 = (librdf_digest *)(argp1);
  librdf_digest_final(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_digest_init(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_digest_init(int argc, VALUE *argv, VALUE self) {
  librdf_digest *arg1 = (librdf_digest *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_digest_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_digest *","librdf_digest_init", 1, argv[0] )); 
  }
  arg1 = (librdf_digest *)(argp1);
  librdf_digest_init(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_digest_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_digest_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_digest *arg1 = (librdf_digest *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_digest_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_digest *","librdf_digest_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_digest *)(argp1);
  result = (char *)librdf_digest_to_string(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_digest_update(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_digest_update(int argc, VALUE *argv, VALUE self) {
  librdf_digest *arg1 = (librdf_digest *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_digest_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_digest *","librdf_digest_update", 1, argv[0] )); 
  }
  arg1 = (librdf_digest *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_digest_update", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","librdf_digest_update", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  librdf_digest_update(arg1,(char const *)arg2,arg3);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_digest_update_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_digest_update_string(int argc, VALUE *argv, VALUE self) {
  librdf_digest *arg1 = (librdf_digest *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_digest_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_digest *","librdf_digest_update_string", 1, argv[0] )); 
  }
  arg1 = (librdf_digest *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_digest_update_string", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  librdf_digest_update_string(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_free_digest(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_digest(int argc, VALUE *argv, VALUE self) {
  librdf_digest *arg1 = (librdf_digest *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_digest_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_digest *","librdf_free_digest", 1, argv[0] )); 
  }
  arg1 = (librdf_digest *)(argp1);
  librdf_free_digest(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_hash(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_hash(int argc, VALUE *argv, VALUE self) {
  librdf_hash *arg1 = (librdf_hash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_hash_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_hash *","librdf_free_hash", 1, argv[0] )); 
  }
  arg1 = (librdf_hash *)(argp1);
  librdf_free_hash(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_iterator(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_iterator(int argc, VALUE *argv, VALUE self) {
  librdf_iterator *arg1 = (librdf_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_iterator_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_iterator *","librdf_free_iterator", 1, argv[0] )); 
  }
  arg1 = (librdf_iterator *)(argp1);
  librdf_free_iterator(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_model(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_model(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_free_model", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  librdf_free_model(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_node(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_node(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_free_node", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  librdf_free_node(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_parser(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_parser(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_free_parser", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  librdf_free_parser(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_query(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_query(int argc, VALUE *argv, VALUE self) {
  librdf_query *arg1 = (librdf_query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query *","librdf_free_query", 1, argv[0] )); 
  }
  arg1 = (librdf_query *)(argp1);
  librdf_free_query(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_query_results(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_query_results(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_free_query_results", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  librdf_free_query_results(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_serializer(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_serializer(int argc, VALUE *argv, VALUE self) {
  librdf_serializer *arg1 = (librdf_serializer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_serializer_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_serializer *","librdf_free_serializer", 1, argv[0] )); 
  }
  arg1 = (librdf_serializer *)(argp1);
  librdf_free_serializer(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_statement(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_free_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  librdf_free_statement(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_storage(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_storage(int argc, VALUE *argv, VALUE self) {
  librdf_storage *arg1 = (librdf_storage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_storage_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_storage *","librdf_free_storage", 1, argv[0] )); 
  }
  arg1 = (librdf_storage *)(argp1);
  librdf_free_storage(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_stream(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_stream(int argc, VALUE *argv, VALUE self) {
  librdf_stream *arg1 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_stream *","librdf_free_stream", 1, argv[0] )); 
  }
  arg1 = (librdf_stream *)(argp1);
  librdf_free_stream(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_uri(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_uri(int argc, VALUE *argv, VALUE self) {
  librdf_uri *arg1 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_uri *","librdf_free_uri", 1, argv[0] )); 
  }
  arg1 = (librdf_uri *)(argp1);
  librdf_free_uri(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_free_world(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_free_world(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_free_world", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  librdf_free_world(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_hash_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_hash_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_hash *arg1 = (librdf_hash *) 0 ;
  char **arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_hash_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_hash *","librdf_hash_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_hash *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *[]","librdf_hash_to_string", 2, argv[1] )); 
  } 
  arg2 = (char **)(argp2);
  result = (char *)librdf_hash_to_string(arg1,(char const *(*))arg2);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_internal_test_error(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_internal_test_error(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_internal_test_error", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  librdf_internal_test_error(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_internal_test_warning(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_internal_test_warning(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_internal_test_warning", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  librdf_internal_test_warning(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_iterator_end(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_iterator_end(int argc, VALUE *argv, VALUE self) {
  librdf_iterator *arg1 = (librdf_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_iterator_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_iterator *","librdf_iterator_end", 1, argv[0] )); 
  }
  arg1 = (librdf_iterator *)(argp1);
  result = (int)librdf_iterator_end(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_iterator_get_context(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_iterator_get_context(int argc, VALUE *argv, VALUE self) {
  librdf_iterator *arg1 = (librdf_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_iterator_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_iterator *","librdf_iterator_get_context", 1, argv[0] )); 
  }
  arg1 = (librdf_iterator *)(argp1);
  result = (librdf_node *)librdf_iterator_get_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_iterator_get_object(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_iterator_get_object(int argc, VALUE *argv, VALUE self) {
  librdf_iterator *arg1 = (librdf_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_iterator_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_iterator *","librdf_iterator_get_object", 1, argv[0] )); 
  }
  arg1 = (librdf_iterator *)(argp1);
  result = (librdf_node *)librdf_iterator_get_object(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_iterator_next(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_iterator_next(int argc, VALUE *argv, VALUE self) {
  librdf_iterator *arg1 = (librdf_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_iterator_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_iterator *","librdf_iterator_next", 1, argv[0] )); 
  }
  arg1 = (librdf_iterator *)(argp1);
  result = (int)librdf_iterator_next(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_log_message_code(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_log_message_code(int argc, VALUE *argv, VALUE self) {
  librdf_log_message *arg1 = (librdf_log_message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_log_message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_log_message *","librdf_log_message_code", 1, argv[0] )); 
  }
  arg1 = (librdf_log_message *)(argp1);
  result = (int)librdf_log_message_code(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_log_message_facility(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_log_message_facility(int argc, VALUE *argv, VALUE self) {
  librdf_log_message *arg1 = (librdf_log_message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_log_message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_log_message *","librdf_log_message_facility", 1, argv[0] )); 
  }
  arg1 = (librdf_log_message *)(argp1);
  result = (int)librdf_log_message_facility(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_log_message_level(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_log_message_level(int argc, VALUE *argv, VALUE self) {
  librdf_log_message *arg1 = (librdf_log_message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_log_message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_log_message *","librdf_log_message_level", 1, argv[0] )); 
  }
  arg1 = (librdf_log_message *)(argp1);
  result = (int)librdf_log_message_level(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_log_message_locator(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_log_message_locator(int argc, VALUE *argv, VALUE self) {
  librdf_log_message *arg1 = (librdf_log_message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  raptor_locator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_log_message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_log_message *","librdf_log_message_locator", 1, argv[0] )); 
  }
  arg1 = (librdf_log_message *)(argp1);
  result = (raptor_locator *)librdf_log_message_locator(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_raptor_locator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_log_message_message(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_log_message_message(int argc, VALUE *argv, VALUE self) {
  librdf_log_message *arg1 = (librdf_log_message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_log_message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_log_message *","librdf_log_message_message", 1, argv[0] )); 
  }
  arg1 = (librdf_log_message *)(argp1);
  result = (char *)librdf_log_message_message(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}
librdf_model_add(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_add(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  librdf_node *arg4 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_add", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_add", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_add", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_add", 4, argv[3] )); 
  }
  arg4 = (librdf_node *)(argp4);
  result = (int)librdf_model_add(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_add_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_add_statement(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_statement *arg2 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_add_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_statement *","librdf_model_add_statement", 2, argv[1] )); 
  }
  arg2 = (librdf_statement *)(argp2);
  result = (int)librdf_model_add_statement(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_add_statements(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_add_statements(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_stream *arg2 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_add_statements", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_stream *","librdf_model_add_statements", 2, argv[1] )); 
  }
  arg2 = (librdf_stream *)(argp2);
  result = (int)librdf_model_add_statements(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_add_string_literal_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_add_string_literal_statement(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) NULL ;
  int arg6 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_add_string_literal_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_add_string_literal_statement", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_add_string_literal_statement", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","librdf_model_add_string_literal_statement", 4, argv[3] ));
  }
  arg4 = (char *)(buf4);
  if (argc > 4) {
    {
      arg5 = (argv[4] == Qnil) ? NULL : STR2CSTR(argv[4]);
    }
  }
  if (argc > 5) {
    ecode6 = SWIG_AsVal_int(argv[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","librdf_model_add_string_literal_statement", 6, argv[5] ));
    } 
    arg6 = (int)(val6);
  }
  result = (int)librdf_model_add_string_literal_statement(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,arg6);
  vresult = SWIG_From_int((int)(result));
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}
librdf_model_add_typed_literal_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_add_typed_literal_statement(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  librdf_uri *arg6 = (librdf_uri *) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_add_typed_literal_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_add_typed_literal_statement", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_add_typed_literal_statement", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","librdf_model_add_typed_literal_statement", 4, argv[3] ));
  }
  arg4 = (char *)(buf4);
  res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char *","librdf_model_add_typed_literal_statement", 5, argv[4] ));
  }
  arg5 = (char *)(buf5);
  if (argc > 5) {
    res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "librdf_uri *","librdf_model_add_typed_literal_statement", 6, argv[5] )); 
    }
    arg6 = (librdf_uri *)(argp6);
  }
  result = (int)librdf_model_add_typed_literal_statement(arg1,arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_From_int((int)(result));
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
  return vresult;
fail:
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
  return Qnil;
}
librdf_model_as_stream(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_as_stream(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_stream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_as_stream", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  result = (librdf_stream *)librdf_model_as_stream(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_contains_context(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_contains_context(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_contains_context", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_contains_context", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  result = (int)librdf_model_contains_context(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_contains_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_contains_statement(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_statement *arg2 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_contains_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_statement *","librdf_model_contains_statement", 2, argv[1] )); 
  }
  arg2 = (librdf_statement *)(argp2);
  result = (int)librdf_model_contains_statement(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_context_add_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_context_add_statement(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_statement *arg3 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_context_add_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_context_add_statement", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_statement *","librdf_model_context_add_statement", 3, argv[2] )); 
  }
  arg3 = (librdf_statement *)(argp3);
  result = (int)librdf_model_context_add_statement(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_context_add_statements(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_context_add_statements(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_stream *arg3 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_context_add_statements", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_context_add_statements", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_stream *","librdf_model_context_add_statements", 3, argv[2] )); 
  }
  arg3 = (librdf_stream *)(argp3);
  result = (int)librdf_model_context_add_statements(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_context_as_stream(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_context_as_stream(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_stream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_context_as_stream", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_context_as_stream", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  result = (librdf_stream *)librdf_model_context_as_stream(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_context_remove_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_context_remove_statement(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_statement *arg3 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_context_remove_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_context_remove_statement", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_statement *","librdf_model_context_remove_statement", 3, argv[2] )); 
  }
  arg3 = (librdf_statement *)(argp3);
  result = (int)librdf_model_context_remove_statement(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_context_remove_statements(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_context_remove_statements(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_context_remove_statements", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_context_remove_statements", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  result = (int)librdf_model_context_remove_statements(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_find_statements(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_find_statements(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_statement *arg2 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_stream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_find_statements", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_statement *","librdf_model_find_statements", 2, argv[1] )); 
  }
  arg2 = (librdf_statement *)(argp2);
  result = (librdf_stream *)librdf_model_find_statements(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_find_statements_in_context(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_find_statements_in_context(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_statement *arg2 = (librdf_statement *) 0 ;
  librdf_node *arg3 = (librdf_node *) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_stream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_find_statements_in_context", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_statement *","librdf_model_find_statements_in_context", 2, argv[1] )); 
  }
  arg2 = (librdf_statement *)(argp2);
  if (argc > 2) {
    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_find_statements_in_context", 3, argv[2] )); 
    }
    arg3 = (librdf_node *)(argp3);
  }
  result = (librdf_stream *)librdf_model_find_statements_in_context(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_arc(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_arc(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_arc", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_arc", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_arc", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (librdf_node *)librdf_model_get_arc(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_arcs(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_arcs(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_iterator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_arcs", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_arcs", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_arcs", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (librdf_iterator *)librdf_model_get_arcs(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_arcs_in(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_arcs_in(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_iterator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_arcs_in", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_arcs_in", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  result = (librdf_iterator *)librdf_model_get_arcs_in(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_arcs_out(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_arcs_out(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_iterator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_arcs_out", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_arcs_out", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  result = (librdf_iterator *)librdf_model_get_arcs_out(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_contexts(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_contexts(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_iterator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_contexts", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  result = (librdf_iterator *)librdf_model_get_contexts(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_feature(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_feature(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_feature", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_model_get_feature", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  result = (librdf_node *)librdf_model_get_feature(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_source(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_source(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_source", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_source", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_source", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (librdf_node *)librdf_model_get_source(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_sources(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_sources(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_iterator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_sources", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_sources", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_sources", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (librdf_iterator *)librdf_model_get_sources(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_target(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_target(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_target", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_target", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_target", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (librdf_node *)librdf_model_get_target(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_get_targets(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_get_targets(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_iterator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_get_targets", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_targets", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_get_targets", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (librdf_iterator *)librdf_model_get_targets(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_iterator_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_has_arc_in(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_has_arc_in(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_has_arc_in", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_has_arc_in", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_has_arc_in", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (int)librdf_model_has_arc_in(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_has_arc_out(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_has_arc_out(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_has_arc_out", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_has_arc_out", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_has_arc_out", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (int)librdf_model_has_arc_out(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_load(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_load(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  char *arg3 = (char *) NULL ;
  char *arg4 = (char *) NULL ;
  librdf_uri *arg5 = (librdf_uri *) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_load", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_model_load", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  if (argc > 2) {
    {
      arg3 = (argv[2] == Qnil) ? NULL : STR2CSTR(argv[2]);
    }
  }
  if (argc > 3) {
    {
      arg4 = (argv[3] == Qnil) ? NULL : STR2CSTR(argv[3]);
    }
  }
  if (argc > 4) {
    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "librdf_uri *","librdf_model_load", 5, argv[4] )); 
    }
    arg5 = (librdf_uri *)(argp5);
  }
  result = (int)librdf_model_load(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_query_execute(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_query_execute(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_query *arg2 = (librdf_query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_query_results *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_query_execute", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_query, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_query *","librdf_model_query_execute", 2, argv[1] )); 
  }
  arg2 = (librdf_query *)(argp2);
  result = (librdf_query_results *)librdf_model_query_execute(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_query_results, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_model_remove_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_remove_statement(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_statement *arg2 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_remove_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_statement *","librdf_model_remove_statement", 2, argv[1] )); 
  }
  arg2 = (librdf_statement *)(argp2);
  result = (int)librdf_model_remove_statement(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_set_feature(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_set_feature(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_set_feature", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_model_set_feature", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_model_set_feature", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (int)librdf_model_set_feature(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_size(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_size(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_size", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  result = (int)librdf_model_size(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_sync(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_sync(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_sync", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  librdf_model_sync(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_model_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  char *arg3 = (char *) NULL ;
  char *arg4 = (char *) NULL ;
  librdf_uri *arg5 = (librdf_uri *) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_model_to_string", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  if (argc > 2) {
    {
      arg3 = (argv[2] == Qnil) ? NULL : STR2CSTR(argv[2]);
    }
  }
  if (argc > 3) {
    {
      arg4 = (argv[3] == Qnil) ? NULL : STR2CSTR(argv[3]);
    }
  }
  if (argc > 4) {
    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "librdf_uri *","librdf_model_to_string", 5, argv[4] )); 
    }
    arg5 = (librdf_uri *)(argp5);
  }
  result = (char *)librdf_model_to_string(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_model_transaction_commit(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_transaction_commit(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_transaction_commit", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  result = (int)librdf_model_transaction_commit(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_transaction_rollback(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_transaction_rollback(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_transaction_rollback", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  result = (int)librdf_model_transaction_rollback(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_model_transaction_start(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_model_transaction_start(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_model_transaction_start", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  result = (int)librdf_model_transaction_start(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_new_digest(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_digest(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  librdf_digest *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_digest", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","librdf_new_digest", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (librdf_digest *)librdf_new_digest(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_digest_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_hash(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_hash(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  librdf_hash *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_hash", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_hash", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (librdf_hash *)librdf_new_hash(arg1,(char const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_hash_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_hash_from_array_of_strings(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_hash_from_array_of_strings(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  char **arg3 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_hash *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_hash_from_array_of_strings", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_hash_from_array_of_strings", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const **","librdf_new_hash_from_array_of_strings", 3, argv[2] )); 
  }
  arg3 = (char **)(argp3);
  result = (librdf_hash *)librdf_new_hash_from_array_of_strings(arg1,(char const *)arg2,(char const **)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_hash_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_hash_from_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_hash_from_string(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  librdf_hash *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_hash_from_string", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_hash_from_string", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_new_hash_from_string", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (librdf_hash *)librdf_new_hash_from_string(arg1,(char const *)arg2,(char const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_hash_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_new_model(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_model(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  librdf_storage *arg2 = (librdf_storage *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  librdf_model *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_model", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_storage_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_storage *","librdf_new_model", 2, argv[1] )); 
  }
  arg2 = (librdf_storage *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","librdf_new_model", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (librdf_model *)librdf_new_model(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_model_s, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_new_model_from_model(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_model_from_model(int argc, VALUE *argv, VALUE self) {
  librdf_model *arg1 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_model *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_model *","librdf_new_model_from_model", 1, argv[0] )); 
  }
  arg1 = (librdf_model *)(argp1);
  result = (librdf_model *)librdf_new_model_from_model(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_model_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_model_with_options(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_model_with_options(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  librdf_storage *arg2 = (librdf_storage *) 0 ;
  librdf_hash *arg3 = (librdf_hash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_model *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_model_with_options", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_storage_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_storage *","librdf_new_model_with_options", 2, argv[1] )); 
  }
  arg2 = (librdf_storage *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_hash_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_hash *","librdf_new_model_with_options", 3, argv[2] )); 
  }
  arg3 = (librdf_hash *)(argp3);
  result = (librdf_model *)librdf_new_model_with_options(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_model_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_node(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_node", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  result = (librdf_node *)librdf_new_node(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_node_from_blank_identifier(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node_from_blank_identifier(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_node_from_blank_identifier", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  if (argc > 1) {
    {
      arg2 = (argv[1] == Qnil) ? NULL : STR2CSTR(argv[1]);
    }
  }
  result = (librdf_node *)librdf_new_node_from_blank_identifier(arg1,(char const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_node_from_literal(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node_from_literal(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) NULL ;
  int arg4 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_node_from_literal", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_node_from_literal", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  if (argc > 2) {
    {
      arg3 = (argv[2] == Qnil) ? NULL : STR2CSTR(argv[2]);
    }
  }
  if (argc > 3) {
    ecode4 = SWIG_AsVal_int(argv[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","librdf_new_node_from_literal", 4, argv[3] ));
    } 
    arg4 = (int)(val4);
  }
  result = (librdf_node *)librdf_new_node_from_literal(arg1,(char const *)arg2,(char const *)arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_node_from_node(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node_from_node(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_new_node_from_node", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (librdf_node *)librdf_new_node_from_node(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_node_from_normalised_uri_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node_from_normalised_uri_string(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  librdf_uri *arg4 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_node_from_normalised_uri_string", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_node_from_normalised_uri_string", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_node_from_normalised_uri_string", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_node_from_normalised_uri_string", 4, argv[3] )); 
  }
  arg4 = (librdf_uri *)(argp4);
  result = (librdf_node *)librdf_new_node_from_normalised_uri_string(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_node_from_typed_literal(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node_from_typed_literal(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) NULL ;
  librdf_uri *arg4 = (librdf_uri *) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_node_from_typed_literal", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_node_from_typed_literal", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  if (argc > 2) {
    {
      arg3 = (argv[2] == Qnil) ? NULL : STR2CSTR(argv[2]);
    }
  }
  if (argc > 3) {
    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_node_from_typed_literal", 4, argv[3] )); 
    }
    arg4 = (librdf_uri *)(argp4);
  }
  result = (librdf_node *)librdf_new_node_from_typed_literal(arg1,(char const *)arg2,(char const *)arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_node_from_uri(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node_from_uri(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_node_from_uri", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_node_from_uri", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  result = (librdf_node *)librdf_new_node_from_uri(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_node_from_uri_local_name(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node_from_uri_local_name(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_node_from_uri_local_name", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_node_from_uri_local_name", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_new_node_from_uri_local_name", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (librdf_node *)librdf_new_node_from_uri_local_name(arg1,arg2,(char const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_new_node_from_uri_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_node_from_uri_string(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_node_from_uri_string", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_node_from_uri_string", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (librdf_node *)librdf_new_node_from_uri_string(arg1,(char const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_parser(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_parser(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  librdf_uri *arg4 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  librdf_parser *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_parser", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_parser", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_new_parser", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_parser", 4, argv[3] )); 
  }
  arg4 = (librdf_uri *)(argp4);
  result = (librdf_parser *)librdf_new_parser(arg1,(char const *)arg2,(char const *)arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_parser_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_new_query(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_query(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  char *arg4 = (char *) 0 ;
  librdf_uri *arg5 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  librdf_query *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_query", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_query", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_query", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","librdf_new_query", 4, argv[3] ));
  }
  arg4 = (char *)(buf4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_query", 5, argv[4] )); 
  }
  arg5 = (librdf_uri *)(argp5);
  result = (librdf_query *)librdf_new_query(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_query, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}
librdf_new_query_from_query(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_query_from_query(int argc, VALUE *argv, VALUE self) {
  librdf_query *arg1 = (librdf_query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_query *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query *","librdf_new_query_from_query", 1, argv[0] )); 
  }
  arg1 = (librdf_query *)(argp1);
  result = (librdf_query *)librdf_new_query_from_query(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_query, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_serializer(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_serializer(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  librdf_uri *arg4 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  librdf_serializer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_serializer", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_serializer", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_new_serializer", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_serializer", 4, argv[3] )); 
  }
  arg4 = (librdf_uri *)(argp4);
  result = (librdf_serializer *)librdf_new_serializer(arg1,(char const *)arg2,(char const *)arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_serializer_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_new_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_statement(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_statement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  result = (librdf_statement *)librdf_new_statement(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_statement_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_statement_from_nodes(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_statement_from_nodes(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  librdf_node *arg4 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  librdf_statement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_statement_from_nodes", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_new_statement_from_nodes", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_new_statement_from_nodes", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_node *","librdf_new_statement_from_nodes", 4, argv[3] )); 
  }
  arg4 = (librdf_node *)(argp4);
  result = (librdf_statement *)librdf_new_statement_from_nodes(arg1,arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_statement_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_statement_from_statement(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_statement_from_statement(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_statement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_new_statement_from_statement", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  result = (librdf_statement *)librdf_new_statement_from_statement(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_statement_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_storage(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_storage(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  librdf_storage *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_storage", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","librdf_new_storage", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","librdf_new_storage", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","librdf_new_storage", 4, argv[3] ));
  }
  arg4 = (char *)(buf4);
  result = (librdf_storage *)librdf_new_storage(arg1,arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_storage_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}
librdf_new_storage_from_storage(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_storage_from_storage(int argc, VALUE *argv, VALUE self) {
  librdf_storage *arg1 = (librdf_storage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_storage *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_storage_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_storage *","librdf_new_storage_from_storage", 1, argv[0] )); 
  }
  arg1 = (librdf_storage *)(argp1);
  result = (librdf_storage *)librdf_new_storage_from_storage(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_storage_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_uri(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_uri(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  librdf_uri *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_uri", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","librdf_new_uri", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (librdf_uri *)librdf_new_uri(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_uri_from_filename(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_uri_from_filename(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  librdf_uri *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_new_uri_from_filename", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_new_uri_from_filename", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (librdf_uri *)librdf_new_uri_from_filename(arg1,(char const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_new_uri_from_uri(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_uri_from_uri(int argc, VALUE *argv, VALUE self) {
  librdf_uri *arg1 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_uri *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_uri *","librdf_new_uri_from_uri", 1, argv[0] )); 
  }
  arg1 = (librdf_uri *)(argp1);
  result = (librdf_uri *)librdf_new_uri_from_uri(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_new_world(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_new_world(int argc, VALUE *argv, VALUE self) {
  librdf_world *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (librdf_world *)librdf_new_world();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_world_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_node_equals(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_equals(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_equals", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_equals", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  result = (int)librdf_node_equals(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_blank_identifier(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_blank_identifier(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_blank_identifier", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (char *)librdf_node_get_blank_identifier(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_li_ordinal(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_li_ordinal(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_li_ordinal", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (int)librdf_node_get_li_ordinal(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_literal_value(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_literal_value(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_literal_value", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (char *)librdf_node_get_literal_value(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_literal_value_as_latin1(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_literal_value_as_latin1(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_literal_value_as_latin1", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (char *)librdf_node_get_literal_value_as_latin1(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_literal_value_datatype_uri(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_literal_value_datatype_uri(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_uri *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_literal_value_datatype_uri", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (librdf_uri *)librdf_node_get_literal_value_datatype_uri(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_literal_value_is_wf_xml(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_literal_value_is_wf_xml(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_literal_value_is_wf_xml", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (int)librdf_node_get_literal_value_is_wf_xml(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_literal_value_language(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_literal_value_language(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_literal_value_language", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (char *)librdf_node_get_literal_value_language(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_type(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_type(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_type", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (int)librdf_node_get_type(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_node_get_uri(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_get_uri(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_uri *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_get_uri", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (librdf_uri *)librdf_node_get_uri(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_node_is_blank(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_is_blank(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_is_blank", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (int)librdf_node_is_blank(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_node_is_literal(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_is_literal(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_is_literal", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (int)librdf_node_is_literal(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_node_is_resource(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_is_resource(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_is_resource", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (int)librdf_node_is_resource(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_node_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_node_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_node *arg1 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_node *","librdf_node_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_node *)(argp1);
  result = (char *)librdf_node_to_string(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_parser_check_name(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_check_name(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_parser_check_name", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_parser_check_name", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)librdf_parser_check_name(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_parser_get_accept_header(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_get_accept_header(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_get_accept_header", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  result = (char *)librdf_parser_get_accept_header(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_parser_get_feature(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_get_feature(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_get_feature", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_get_feature", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  result = (librdf_node *)librdf_parser_get_feature(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_parser_get_namespaces_seen_count(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_get_namespaces_seen_count(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_get_namespaces_seen_count", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  result = (int)librdf_parser_get_namespaces_seen_count(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_parser_get_namespaces_seen_prefix(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_get_namespaces_seen_prefix(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_get_namespaces_seen_prefix", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","librdf_parser_get_namespaces_seen_prefix", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (char *)librdf_parser_get_namespaces_seen_prefix(arg1,arg2);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}
librdf_parser_get_namespaces_seen_uri(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_get_namespaces_seen_uri(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  librdf_uri *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_get_namespaces_seen_uri", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","librdf_parser_get_namespaces_seen_uri", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (librdf_uri *)librdf_parser_get_namespaces_seen_uri(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_parser_guess_name(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_guess_name(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","librdf_parser_guess_name", 1, argv[0] ));
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_parser_guess_name", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_parser_guess_name", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (char *)librdf_parser_guess_name((char const *)arg1,(char const *)arg2,(char const *)arg3);
  vresult = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_parser_guess_name2(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_guess_name2(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_parser_guess_name2", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_parser_guess_name2", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_parser_guess_name2", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","librdf_parser_guess_name2", 4, argv[3] ));
  }
  arg4 = (char *)(buf4);
  result = (char *)librdf_parser_guess_name2(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
  vresult = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}
librdf_parser_parse_as_stream(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_parse_as_stream(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_stream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_parse_as_stream", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_parse_as_stream", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  if (argc > 2) {
    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_parse_as_stream", 3, argv[2] )); 
    }
    arg3 = (librdf_uri *)(argp3);
  }
  result = (librdf_stream *)librdf_parser_parse_as_stream(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_parser_parse_counted_string_as_stream(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_parse_counted_string_as_stream(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  librdf_uri *arg4 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  librdf_stream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_parse_counted_string_as_stream", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_parser_parse_counted_string_as_stream", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","librdf_parser_parse_counted_string_as_stream", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_parse_counted_string_as_stream", 4, argv[3] )); 
  }
  arg4 = (librdf_uri *)(argp4);
  result = (librdf_stream *)librdf_parser_parse_counted_string_as_stream(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_parser_parse_counted_string_into_model(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_parse_counted_string_into_model(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  librdf_uri *arg4 = (librdf_uri *) 0 ;
  librdf_model *arg5 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_parse_counted_string_into_model", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_parser_parse_counted_string_into_model", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","librdf_parser_parse_counted_string_into_model", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_parse_counted_string_into_model", 4, argv[3] )); 
  }
  arg4 = (librdf_uri *)(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "librdf_model *","librdf_parser_parse_counted_string_into_model", 5, argv[4] )); 
  }
  arg5 = (librdf_model *)(argp5);
  result = (int)librdf_parser_parse_counted_string_into_model(arg1,(char const *)arg2,arg3,arg4,arg5);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_parser_parse_into_model(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_parse_into_model(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  librdf_model *arg4 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_parse_into_model", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_parse_into_model", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_parse_into_model", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_model *","librdf_parser_parse_into_model", 4, argv[3] )); 
  }
  arg4 = (librdf_model *)(argp4);
  result = (int)librdf_parser_parse_into_model(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_parser_parse_string_as_stream(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_parse_string_as_stream(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  char *arg2 = (char *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  librdf_stream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_parse_string_as_stream", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_parser_parse_string_as_stream", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_parse_string_as_stream", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  result = (librdf_stream *)librdf_parser_parse_string_as_stream(arg1,(char const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_parser_parse_string_into_model(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_parse_string_into_model(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  char *arg2 = (char *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  librdf_model *arg4 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_parse_string_into_model", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_parser_parse_string_into_model", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_parse_string_into_model", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_model *","librdf_parser_parse_string_into_model", 4, argv[3] )); 
  }
  arg4 = (librdf_model *)(argp4);
  result = (int)librdf_parser_parse_string_into_model(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_parser_set_feature(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_parser_set_feature(int argc, VALUE *argv, VALUE self) {
  librdf_parser *arg1 = (librdf_parser *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_parser_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_parser *","librdf_parser_set_feature", 1, argv[0] )); 
  }
  arg1 = (librdf_parser *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_parser_set_feature", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_parser_set_feature", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (int)librdf_parser_set_feature(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_execute(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_execute(int argc, VALUE *argv, VALUE self) {
  librdf_query *arg1 = (librdf_query *) 0 ;
  librdf_model *arg2 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_query_results *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query *","librdf_query_execute", 1, argv[0] )); 
  }
  arg1 = (librdf_query *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_model *","librdf_query_execute", 2, argv[1] )); 
  }
  arg2 = (librdf_model *)(argp2);
  result = (librdf_query_results *)librdf_query_execute(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_query_results, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_query_get_limit(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_get_limit(int argc, VALUE *argv, VALUE self) {
  librdf_query *arg1 = (librdf_query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query *","librdf_query_get_limit", 1, argv[0] )); 
  }
  arg1 = (librdf_query *)(argp1);
  result = (int)librdf_query_get_limit(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_get_offset(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_get_offset(int argc, VALUE *argv, VALUE self) {
  librdf_query *arg1 = (librdf_query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query *","librdf_query_get_offset", 1, argv[0] )); 
  }
  arg1 = (librdf_query *)(argp1);
  result = (int)librdf_query_get_offset(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_as_stream(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_as_stream(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_stream *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_as_stream", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (librdf_stream *)librdf_query_results_as_stream(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_stream_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_finished(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_finished(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_finished", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_finished(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_get_binding_name(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_get_binding_name(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_get_binding_name", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","librdf_query_results_get_binding_name", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (char *)librdf_query_results_get_binding_name(arg1,arg2);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_get_binding_value(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_get_binding_value(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_get_binding_value", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","librdf_query_results_get_binding_value", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (librdf_node *)librdf_query_results_get_binding_value(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_get_binding_value_by_name(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_get_binding_value_by_name(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_get_binding_value_by_name", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_query_results_get_binding_value_by_name", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (librdf_node *)librdf_query_results_get_binding_value_by_name(arg1,(char const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_query_results_get_bindings_count(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_get_bindings_count(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_get_bindings_count", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_get_bindings_count(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_get_boolean(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_get_boolean(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_get_boolean", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_get_boolean(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_get_count(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_get_count(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_get_count", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_get_count(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_is_bindings(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_is_bindings(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_is_bindings", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_is_bindings(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_is_boolean(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_is_boolean(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_is_boolean", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_is_boolean(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_is_graph(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_is_graph(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_is_graph", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_is_graph(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_is_syntax(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_is_syntax(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_is_syntax", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_is_syntax(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_next(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_next(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_next", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  result = (int)librdf_query_results_next(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_to_file(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_to_file(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  char *arg2 = (char *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  librdf_uri *arg4 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_to_file", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_query_results_to_file", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_query_results_to_file", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_query_results_to_file", 4, argv[3] )); 
  }
  arg4 = (librdf_uri *)(argp4);
  result = (int)librdf_query_results_to_file(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_query_results_to_file2(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_to_file2(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  librdf_uri *arg4 = (librdf_uri *) 0 ;
  librdf_uri *arg5 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_to_file2", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_query_results_to_file2", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_query_results_to_file2", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_query_results_to_file2", 4, argv[3] )); 
  }
  arg4 = (librdf_uri *)(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "librdf_uri *","librdf_query_results_to_file2", 5, argv[4] )); 
  }
  arg5 = (librdf_uri *)(argp5);
  result = (int)librdf_query_results_to_file2(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_query_results_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_query_results_to_string", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_query_results_to_string", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  result = (char *)librdf_query_results_to_string(arg1,arg2,arg3);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_query_results_to_string2(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_results_to_string2(int argc, VALUE *argv, VALUE self) {
  librdf_query_results *arg1 = (librdf_query_results *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  librdf_uri *arg4 = (librdf_uri *) 0 ;
  librdf_uri *arg5 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query_results, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query_results *","librdf_query_results_to_string2", 1, argv[0] )); 
  }
  arg1 = (librdf_query_results *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_query_results_to_string2", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_query_results_to_string2", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_uri *","librdf_query_results_to_string2", 4, argv[3] )); 
  }
  arg4 = (librdf_uri *)(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "librdf_uri *","librdf_query_results_to_string2", 5, argv[4] )); 
  }
  arg5 = (librdf_uri *)(argp5);
  result = (char *)librdf_query_results_to_string2(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  free((char*)result);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_query_set_limit(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_set_limit(int argc, VALUE *argv, VALUE self) {
  librdf_query *arg1 = (librdf_query *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query *","librdf_query_set_limit", 1, argv[0] )); 
  }
  arg1 = (librdf_query *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","librdf_query_set_limit", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (int)librdf_query_set_limit(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_query_set_offset(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_query_set_offset(int argc, VALUE *argv, VALUE self) {
  librdf_query *arg1 = (librdf_query *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_query *","librdf_query_set_offset", 1, argv[0] )); 
  }
  arg1 = (librdf_query *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","librdf_query_set_offset", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (int)librdf_query_set_offset(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_serializer_check_name(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_serializer_check_name(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_serializer_check_name", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_serializer_check_name", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)librdf_serializer_check_name(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_serializer_get_feature(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_serializer_get_feature(int argc, VALUE *argv, VALUE self) {
  librdf_serializer *arg1 = (librdf_serializer *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_serializer_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_serializer *","librdf_serializer_get_feature", 1, argv[0] )); 
  }
  arg1 = (librdf_serializer *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_serializer_get_feature", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  result = (librdf_node *)librdf_serializer_get_feature(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_serializer_serialize_model_to_file(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_serializer_serialize_model_to_file(int argc, VALUE *argv, VALUE self) {
  librdf_serializer *arg1 = (librdf_serializer *) 0 ;
  char *arg2 = (char *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  librdf_model *arg4 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_serializer_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_serializer *","librdf_serializer_serialize_model_to_file", 1, argv[0] )); 
  }
  arg1 = (librdf_serializer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_serializer_serialize_model_to_file", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_serializer_serialize_model_to_file", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_model *","librdf_serializer_serialize_model_to_file", 4, argv[3] )); 
  }
  arg4 = (librdf_model *)(argp4);
  result = (int)librdf_serializer_serialize_model_to_file(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_serializer_serialize_model_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_serializer_serialize_model_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_serializer *arg1 = (librdf_serializer *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_model *arg3 = (librdf_model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_serializer_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_serializer *","librdf_serializer_serialize_model_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_serializer *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_serializer_serialize_model_to_string", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_model_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_model *","librdf_serializer_serialize_model_to_string", 3, argv[2] )); 
  }
  arg3 = (librdf_model *)(argp3);
  result = (char *)librdf_serializer_serialize_model_to_string(arg1,arg2,arg3);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_serializer_serialize_stream_to_file(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_serializer_serialize_stream_to_file(int argc, VALUE *argv, VALUE self) {
  librdf_serializer *arg1 = (librdf_serializer *) 0 ;
  char *arg2 = (char *) 0 ;
  librdf_uri *arg3 = (librdf_uri *) 0 ;
  librdf_stream *arg4 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_serializer_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_serializer *","librdf_serializer_serialize_stream_to_file", 1, argv[0] )); 
  }
  arg1 = (librdf_serializer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","librdf_serializer_serialize_stream_to_file", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_uri *","librdf_serializer_serialize_stream_to_file", 3, argv[2] )); 
  }
  arg3 = (librdf_uri *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "librdf_stream *","librdf_serializer_serialize_stream_to_file", 4, argv[3] )); 
  }
  arg4 = (librdf_stream *)(argp4);
  result = (int)librdf_serializer_serialize_stream_to_file(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}
librdf_serializer_serialize_stream_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_serializer_serialize_stream_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_serializer *arg1 = (librdf_serializer *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_stream *arg3 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_serializer_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_serializer *","librdf_serializer_serialize_stream_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_serializer *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_serializer_serialize_stream_to_string", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_stream *","librdf_serializer_serialize_stream_to_string", 3, argv[2] )); 
  }
  arg3 = (librdf_stream *)(argp3);
  result = (char *)librdf_serializer_serialize_stream_to_string(arg1,arg2,arg3);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_serializer_set_feature(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_serializer_set_feature(int argc, VALUE *argv, VALUE self) {
  librdf_serializer *arg1 = (librdf_serializer *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_serializer_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_serializer *","librdf_serializer_set_feature", 1, argv[0] )); 
  }
  arg1 = (librdf_serializer *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_serializer_set_feature", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_serializer_set_feature", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (int)librdf_serializer_set_feature(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_serializer_set_namespace(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_serializer_set_namespace(int argc, VALUE *argv, VALUE self) {
  librdf_serializer *arg1 = (librdf_serializer *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_serializer_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_serializer *","librdf_serializer_set_namespace", 1, argv[0] )); 
  }
  arg1 = (librdf_serializer *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_serializer_set_namespace", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","librdf_serializer_set_namespace", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (int)librdf_serializer_set_namespace(arg1,arg2,(char const *)arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}
librdf_statement_equals(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_equals(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  librdf_statement *arg2 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_equals", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_equals", 2, argv[1] )); 
  }
  arg2 = (librdf_statement *)(argp2);
  result = (int)librdf_statement_equals(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_statement_get_object(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_get_object(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_get_object", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  result = (librdf_node *)librdf_statement_get_object(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_statement_get_predicate(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_get_predicate(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_get_predicate", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  result = (librdf_node *)librdf_statement_get_predicate(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_statement_get_subject(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_get_subject(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_get_subject", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  result = (librdf_node *)librdf_statement_get_subject(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_statement_is_complete(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_is_complete(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_is_complete", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  result = (int)librdf_statement_is_complete(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_statement_match(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_match(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  librdf_statement *arg2 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_match", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_match", 2, argv[1] )); 
  }
  arg2 = (librdf_statement *)(argp2);
  result = (int)librdf_statement_match(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_statement_set_object(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_set_object(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_set_object", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_statement_set_object", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  librdf_statement_set_object(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
librdf_statement_set_predicate(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_set_predicate(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_set_predicate", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_statement_set_predicate", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  librdf_statement_set_predicate(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
librdf_statement_set_subject(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_set_subject(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  librdf_node *arg2 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_set_subject", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_node *","librdf_statement_set_subject", 2, argv[1] )); 
  }
  arg2 = (librdf_node *)(argp2);
  librdf_statement_set_subject(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
librdf_statement_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_statement_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_statement *arg1 = (librdf_statement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_statement *","librdf_statement_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_statement *)(argp1);
  result = (char *)librdf_statement_to_string(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_stream_end(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_stream_end(int argc, VALUE *argv, VALUE self) {
  librdf_stream *arg1 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_stream *","librdf_stream_end", 1, argv[0] )); 
  }
  arg1 = (librdf_stream *)(argp1);
  result = (int)librdf_stream_end(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_stream_get_context(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_stream_get_context(int argc, VALUE *argv, VALUE self) {
  librdf_stream *arg1 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_stream *","librdf_stream_get_context", 1, argv[0] )); 
  }
  arg1 = (librdf_stream *)(argp1);
  result = (librdf_node *)librdf_stream_get_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_stream_get_object(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_stream_get_object(int argc, VALUE *argv, VALUE self) {
  librdf_stream *arg1 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  librdf_statement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_stream *","librdf_stream_get_object", 1, argv[0] )); 
  }
  arg1 = (librdf_stream *)(argp1);
  result = (librdf_statement *)librdf_stream_get_object(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_statement_s, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_stream_next(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_stream_next(int argc, VALUE *argv, VALUE self) {
  librdf_stream *arg1 = (librdf_stream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_stream_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_stream *","librdf_stream_next", 1, argv[0] )); 
  }
  arg1 = (librdf_stream *)(argp1);
  result = (int)librdf_stream_next(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_uri_compare(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_uri_compare(int argc, VALUE *argv, VALUE self) {
  librdf_uri *arg1 = (librdf_uri *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_uri *","librdf_uri_compare", 1, argv[0] )); 
  }
  arg1 = (librdf_uri *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_uri_compare", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  result = (int)librdf_uri_compare(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_uri_equals(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_uri_equals(int argc, VALUE *argv, VALUE self) {
  librdf_uri *arg1 = (librdf_uri *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_uri *","librdf_uri_equals", 1, argv[0] )); 
  }
  arg1 = (librdf_uri *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_uri_equals", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  result = (int)librdf_uri_equals(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_uri_to_string(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_uri_to_string(int argc, VALUE *argv, VALUE self) {
  librdf_uri *arg1 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_uri *","librdf_uri_to_string", 1, argv[0] )); 
  }
  arg1 = (librdf_uri *)(argp1);
  result = (char *)librdf_uri_to_string(arg1);
  {
    vresult = (result == NULL) ? Qnil : rb_str_new2(result);
  }
  free((char*)result);
  return vresult;
fail:
  return Qnil;
}
librdf_version_decimal() click to toggle source
SWIGINTERN VALUE
_wrap_librdf_version_decimal_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(librdf_version_decimal));
  return _val;
}
librdf_version_major() click to toggle source
SWIGINTERN VALUE
_wrap_librdf_version_major_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(librdf_version_major));
  return _val;
}
librdf_version_minor() click to toggle source
SWIGINTERN VALUE
_wrap_librdf_version_minor_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(librdf_version_minor));
  return _val;
}
librdf_version_release() click to toggle source
SWIGINTERN VALUE
_wrap_librdf_version_release_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(librdf_version_release));
  return _val;
}
librdf_version_string() click to toggle source
SWIGINTERN VALUE
_wrap_librdf_version_string_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(librdf_version_string);
  return _val;
}
librdf_world_get_feature(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_world_get_feature(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  librdf_node *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_world_get_feature", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_world_get_feature", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  result = (librdf_node *)librdf_world_get_feature(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_librdf_node_s, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}
librdf_world_open(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_world_open(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_world_open", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  librdf_world_open(arg1);
  return Qnil;
fail:
  return Qnil;
}
librdf_world_set_feature(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_world_set_feature(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  librdf_uri *arg2 = (librdf_uri *) 0 ;
  librdf_node *arg3 = (librdf_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_world_set_feature", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_librdf_uri_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "librdf_uri *","librdf_world_set_feature", 2, argv[1] )); 
  }
  arg2 = (librdf_uri *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_librdf_node_s, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_node *","librdf_world_set_feature", 3, argv[2] )); 
  }
  arg3 = (librdf_node *)(argp3);
  result = (int)librdf_world_set_feature(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
librdf_world_set_logger(*args) click to toggle source
SWIGINTERN VALUE
_wrap_librdf_world_set_logger(int argc, VALUE *argv, VALUE self) {
  librdf_world *arg1 = (librdf_world *) 0 ;
  void *arg2 = (void *) 0 ;
  librdf_log_func arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_librdf_world_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "librdf_world *","librdf_world_set_logger", 1, argv[0] )); 
  }
  arg1 = (librdf_world *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","librdf_world_set_logger", 2, argv[1] )); 
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_librdf_log_func,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "librdf_log_func","librdf_world_set_logger", 3, argv[2] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "librdf_log_func","librdf_world_set_logger", 3, argv[2]));
    } else {
      arg3 = *((librdf_log_func *)(argp3));
    }
  }
  librdf_world_set_logger(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
raptor_locator_byte(*args) click to toggle source
SWIGINTERN VALUE
_wrap_raptor_locator_byte(int argc, VALUE *argv, VALUE self) {
  raptor_locator *arg1 = (raptor_locator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_raptor_locator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "raptor_locator *","raptor_locator_byte", 1, argv[0] )); 
  }
  arg1 = (raptor_locator *)(argp1);
  result = (int)raptor_locator_byte(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
raptor_locator_column(*args) click to toggle source
SWIGINTERN VALUE
_wrap_raptor_locator_column(int argc, VALUE *argv, VALUE self) {
  raptor_locator *arg1 = (raptor_locator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_raptor_locator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "raptor_locator *","raptor_locator_column", 1, argv[0] )); 
  }
  arg1 = (raptor_locator *)(argp1);
  result = (int)raptor_locator_column(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
raptor_locator_file(*args) click to toggle source
SWIGINTERN VALUE
_wrap_raptor_locator_file(int argc, VALUE *argv, VALUE self) {
  raptor_locator *arg1 = (raptor_locator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_raptor_locator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "raptor_locator *","raptor_locator_file", 1, argv[0] )); 
  }
  arg1 = (raptor_locator *)(argp1);
  result = (char *)raptor_locator_file(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}
raptor_locator_line(*args) click to toggle source
SWIGINTERN VALUE
_wrap_raptor_locator_line(int argc, VALUE *argv, VALUE self) {
  raptor_locator *arg1 = (raptor_locator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_raptor_locator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "raptor_locator *","raptor_locator_line", 1, argv[0] )); 
  }
  arg1 = (raptor_locator *)(argp1);
  result = (int)raptor_locator_line(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}
raptor_locator_uri(*args) click to toggle source
SWIGINTERN VALUE
_wrap_raptor_locator_uri(int argc, VALUE *argv, VALUE self) {
  raptor_locator *arg1 = (raptor_locator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_raptor_locator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "raptor_locator *","raptor_locator_uri", 1, argv[0] )); 
  }
  arg1 = (raptor_locator *)(argp1);
  result = (char *)raptor_locator_uri(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}
raptor_version_decimal() click to toggle source
SWIGINTERN VALUE
_wrap_raptor_version_decimal_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(raptor_version_decimal));
  return _val;
}
raptor_version_major() click to toggle source
SWIGINTERN VALUE
_wrap_raptor_version_major_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(raptor_version_major));
  return _val;
}
raptor_version_minor() click to toggle source
SWIGINTERN VALUE
_wrap_raptor_version_minor_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(raptor_version_minor));
  return _val;
}
raptor_version_release() click to toggle source
SWIGINTERN VALUE
_wrap_raptor_version_release_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(raptor_version_release));
  return _val;
}
raptor_version_string() click to toggle source
SWIGINTERN VALUE
_wrap_raptor_version_string_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(raptor_version_string);
  return _val;
}
rasqal_version_decimal() click to toggle source
SWIGINTERN VALUE
_wrap_rasqal_version_decimal_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(rasqal_version_decimal));
  return _val;
}
rasqal_version_major() click to toggle source
SWIGINTERN VALUE
_wrap_rasqal_version_major_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(rasqal_version_major));
  return _val;
}
rasqal_version_minor() click to toggle source
SWIGINTERN VALUE
_wrap_rasqal_version_minor_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(rasqal_version_minor));
  return _val;
}
rasqal_version_release() click to toggle source
SWIGINTERN VALUE
_wrap_rasqal_version_release_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int((unsigned int)(rasqal_version_release));
  return _val;
}
rasqal_version_string() click to toggle source
SWIGINTERN VALUE
_wrap_rasqal_version_string_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(rasqal_version_string);
  return _val;
}

[Validate]

Generated with the Darkfish Rdoc Generator 2.