KappaCUDA 1.2.1 → 1.3.0

data/KappaCUDA.i

@@ -11,7 +11,7 @@
 
 #ifdef SWIGPERL
 %perlcode %{
-$KappaCUDA::VERSION = '1.2.0';
+$KappaCUDA::VERSION = '1.3.0';
 %}
 #endif
 
@@ -25,6 +25,11 @@ $KappaCUDA::VERSION = '1.2.0';
 %ignore kappa::Value::Type;
 #endif
 
+#ifdef SWIGCSHARP
+// This gives a compile warning.
+%ignore kappa::Command::GetType;
+#endif
+
 // Ignore non-exported (hidden) methods and variables
 %ignore kappa::Kappa::Cancel;
 %ignore kappa::Kappa::End;
@@ -34,12 +39,16 @@ $KappaCUDA::VERSION = '1.2.0';
 %ignore cuDevice;
 %ignore kappa_version;
 %ignore kappa::Process::Process;
+#ifndef SWIGCSHARP
 %ignore kappa::Process::GetIOCallbackFunction;
+#endif
 %ignore kappa::Resource::Resource;
 %ignore kappa::Resource::CommandDone;
 %ignore kappa::Resource::CheckCommandReady;
 %ignore kappa::Context::Context;
+#ifndef SWIGCSHARP
 %ignore kappa::Recipient;
+#endif
 %ignore kappa::Variable::Variable;
 %ignore kappa::Array::Array;
 %ignore kappa::DeviceMemory;
@@ -72,6 +81,9 @@ $KappaCUDA::VERSION = '1.2.0';
 #include "kappa/Command.h"
 #include "kappa/Variable.h"
 #include "kappa/Array.h"
+#ifdef SWIGCSHARP
+#include "kappa/Recipient.h"
+#endif
 
 KAPPA_DLL_EXPORT int *intptr_fromvoidptr(void *voidptr);
 KAPPA_DLL_EXPORT unsigned *unsignedptr_fromvoidptr(void *voidptr);

data/KappaCUDA_wrap.cpp

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.2.0
+ * Version 1.3.0
  * 
  * This file is not intended to be easily readable and contains a number of 
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -2255,6 +2255,9 @@ SWIGINTERN doubleArray *doubleArray_frompointer(double *t){
 #include "kappa/Command.h"
 #include "kappa/Variable.h"
 #include "kappa/Array.h"
+#ifdef SWIGCSHARP
+#include "kappa/Recipient.h"
+#endif
 
 KAPPA_DLL_EXPORT int *intptr_fromvoidptr(void *voidptr);
 KAPPA_DLL_EXPORT unsigned *unsignedptr_fromvoidptr(void *voidptr);
@@ -5771,6 +5774,89 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Kappa_StartThread(int argc, VALUE *argv, VALUE self) {
+  kappa::KAPPA_PROCESS arg1 = (kappa::KAPPA_PROCESS) 0 ;
+  void *arg2 = (void *) 0 ;
+  int res2 ;
+  kappa::KappaThread result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_void__p_void);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "kappa::KAPPA_PROCESS","kappa::Kappa::StartThread", 1, argv[0] )); 
+    }
+  }
+  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 *","kappa::Kappa::StartThread", 2, argv[1] )); 
+  }
+  result = kappa::Kappa::StartThread(arg1,arg2);
+  vresult = SWIG_NewPointerObj((new kappa::KappaThread(static_cast< const kappa::KappaThread& >(result))), SWIGTYPE_p_pthread_t, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Kappa_WaitForThread(int argc, VALUE *argv, VALUE self) {
+  kappa::KappaThread arg1 ;
+  void *argp1 ;
+  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_pthread_t,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kappa::KappaThread","kappa::Kappa::WaitForThread", 1, argv[0] )); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kappa::KappaThread","kappa::Kappa::WaitForThread", 1, argv[0]));
+    } else {
+      arg1 = *(reinterpret_cast< kappa::KappaThread * >(argp1));
+    }
+  }
+  kappa::Kappa::WaitForThread(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Kappa_CancelThread(int argc, VALUE *argv, VALUE self) {
+  kappa::KappaThread arg1 ;
+  void *argp1 ;
+  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_pthread_t,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kappa::KappaThread","kappa::Kappa::CancelThread", 1, argv[0] )); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kappa::KappaThread","kappa::Kappa::CancelThread", 1, argv[0]));
+    } else {
+      arg1 = *(reinterpret_cast< kappa::KappaThread * >(argp1));
+    }
+  }
+  kappa::Kappa::CancelThread(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
 swig_class SwigClassKappaConfig;
 
 SWIGINTERN void
@@ -8498,6 +8584,82 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Process_SetLabelRanges(int argc, VALUE *argv, VALUE self) {
+  kappa::Process *arg1 = (kappa::Process *) 0 ;
+  std::string arg2 ;
+  kappa::Arguments *arg3 = (kappa::Arguments *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  bool 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(self, &argp1,SWIGTYPE_p_kappa__Process, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kappa::Process *","SetLabelRanges", 1, self )); 
+  }
+  arg1 = reinterpret_cast< kappa::Process * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","SetLabelRanges", 2, argv[0] )); 
+    }
+    arg2 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_kappa__Arguments, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kappa::Arguments *","SetLabelRanges", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< kappa::Arguments * >(argp3);
+  result = (bool)(arg1)->SetLabelRanges(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Process_ClearLabelRanges(int argc, VALUE *argv, VALUE self) {
+  kappa::Process *arg1 = (kappa::Process *) 0 ;
+  std::string arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool 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(self, &argp1,SWIGTYPE_p_kappa__Process, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kappa::Process *","ClearLabelRanges", 1, self )); 
+  }
+  arg1 = reinterpret_cast< kappa::Process * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","ClearLabelRanges", 2, argv[0] )); 
+    }
+    arg2 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (bool)(arg1)->ClearLabelRanges(arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 swig_class SwigClassResult;
 
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
@@ -24718,6 +24880,38 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Context_SetPrintfFIFOSize(int argc, VALUE *argv, VALUE self) {
+  kappa::Context *arg1 = (kappa::Context *) 0 ;
+  size_t arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  kappa::Context *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(self, &argp1,SWIGTYPE_p_kappa__Context, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kappa::Context *","SetPrintfFIFOSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< kappa::Context * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","SetPrintfFIFOSize", 2, argv[0] ));
+  } 
+  arg2 = static_cast< size_t >(val2);
+  result = (kappa::Context *) &(arg1)->SetPrintfFIFOSize(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kappa__Context, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 swig_class SwigClassCommand;
 
 SWIGINTERN VALUE
@@ -29764,6 +29958,9 @@ SWIGEXPORT void Init_KappaCUDA(void) {
   rb_define_method(SwigClassKappa.klass, "Registered", VALUEFUNC(_wrap_Kappa_Registered), -1);
   rb_define_singleton_method(SwigClassKappa.klass, "Instance", VALUEFUNC(_wrap_Kappa_Instance), -1);
   rb_define_method(SwigClassKappa.klass, "NewDBDriver", VALUEFUNC(_wrap_Kappa_NewDBDriver), -1);
+  rb_define_singleton_method(SwigClassKappa.klass, "StartThread", VALUEFUNC(_wrap_Kappa_StartThread), -1);
+  rb_define_singleton_method(SwigClassKappa.klass, "WaitForThread", VALUEFUNC(_wrap_Kappa_WaitForThread), -1);
+  rb_define_singleton_method(SwigClassKappa.klass, "CancelThread", VALUEFUNC(_wrap_Kappa_CancelThread), -1);
   SwigClassKappa.mark = 0;
   SwigClassKappa.destroy = (void (*)(void *)) free_kappa_Kappa;
   SwigClassKappa.trackObjects = 0;
@@ -29832,6 +30029,8 @@ SWIGEXPORT void Init_KappaCUDA(void) {
   rb_define_method(SwigClassProcess.klass, "ExpandRoutine", VALUEFUNC(_wrap_Process_ExpandRoutine), -1);
   rb_define_method(SwigClassProcess.klass, "DBDriver", VALUEFUNC(_wrap_Process_DBDriver), -1);
   rb_define_method(SwigClassProcess.klass, "FreeDBDriver", VALUEFUNC(_wrap_Process_FreeDBDriver), -1);
+  rb_define_method(SwigClassProcess.klass, "SetLabelRanges", VALUEFUNC(_wrap_Process_SetLabelRanges), -1);
+  rb_define_method(SwigClassProcess.klass, "ClearLabelRanges", VALUEFUNC(_wrap_Process_ClearLabelRanges), -1);
   SwigClassProcess.mark = 0;
   SwigClassProcess.destroy = (void (*)(void *)) free_kappa_Process;
   SwigClassProcess.trackObjects = 0;
@@ -30032,6 +30231,7 @@ SWIGEXPORT void Init_KappaCUDA(void) {
   rb_define_method(SwigClassContext.klass, "MemoryFree", VALUEFUNC(_wrap_Context_MemoryFree), -1);
   rb_define_method(SwigClassContext.klass, "MemoryTotal", VALUEFUNC(_wrap_Context_MemoryTotal), -1);
   rb_define_method(SwigClassContext.klass, "MemoryUsed", VALUEFUNC(_wrap_Context_MemoryUsed), -1);
+  rb_define_method(SwigClassContext.klass, "SetPrintfFIFOSize", VALUEFUNC(_wrap_Context_SetPrintfFIFOSize), -1);
   SwigClassContext.mark = 0;
   SwigClassContext.destroy = (void (*)(void *)) free_kappa_Context;
   SwigClassContext.trackObjects = 0;

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: KappaCUDA
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 1
-  - 2
-  - 1
-  version: 1.2.1
+  - 3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Psi Lambda LLC
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-28 00:00:00 -05:00
+date: 2010-07-17 00:00:00 -05:00
 default_executable: 
 dependencies: []