Merge branch 'ruby-shared-ptr'
* ruby-shared-ptr: Add more Ruby shared_ptr runtime tests Add RUBYFLAGS for Ruby testing li_boost_shared_ptr tests cleanup Ruby shared_ptr testing enhancements Add shared_ptr Ruby runtime test SWIG_Ruby_ConvertPtrAndOwn changes for smartptr feature Fix Ruby smartptr feature for classes in a namespace Turn on missing shared_ptr tests for Octave Turn on Ruby shared_ptr testing shared_ptr typemap error message fix for global variables Add Ruby shared_ptr support smartptr feature support - factor out common code Add Ruby shared_ptr typemaps Ruby ownership refactor ready for smart pointers Ruby free function declaration change
This commit is contained in:
William S Fulton
commit
9d79864ae7
29 changed files with 1226 additions and 192 deletions
|
|
@ -1096,7 +1096,7 @@ ruby_cpp_static: $(SRCDIR_SRCS)
|
|||
# -----------------------------------------------------------------
|
||||
|
||||
ruby_run:
|
||||
$(RUNTOOL) $(RUBY) -I. $(RUBY_SCRIPT) $(RUNPIPE)
|
||||
$(RUNTOOL) $(RUBY) $(RUBYFLAGS) -I. $(RUBY_SCRIPT) $(RUNPIPE)
|
||||
|
||||
# -----------------------------------------------------------------
|
||||
# Version display
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ public:
|
|||
|
||||
%}
|
||||
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD)
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
|
||||
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@
|
|||
# define SWIG_SHARED_PTR_NAMESPACE SwigBoost
|
||||
#endif
|
||||
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE)
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
|
||||
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
%module li_boost_shared_ptr_attribute
|
||||
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD)
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
|
||||
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
%module li_boost_shared_ptr_bits
|
||||
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD)
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
|
||||
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
|
||||
%}
|
||||
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD)
|
||||
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
|
||||
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -503,7 +503,6 @@ function runtest()
|
|||
#KTODO cvar.GlobalPointer = None
|
||||
|
||||
# plain reference
|
||||
kglobal;
|
||||
k = Klass("global reference");
|
||||
cvar.GlobalReference = k;
|
||||
verifyCount(1, k)
|
||||
|
|
|
|||
|
|
@ -521,7 +521,6 @@ class li_boost_shared_ptr_runme:
|
|||
li_boost_shared_ptr.cvar.GlobalPointer = None
|
||||
|
||||
# plain reference
|
||||
kglobal
|
||||
|
||||
k = li_boost_shared_ptr.Klass("global reference")
|
||||
li_boost_shared_ptr.cvar.GlobalReference = k
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ ruby_naming.cpptest: SWIGOPT += -autorename
|
|||
# a file is found which has _runme.rb appended after the testcase name.
|
||||
run_testcase = \
|
||||
if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
|
||||
env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(RUBY) -I$(srcdir):. $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
|
||||
env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(RUBY) $(RUBYFLAGS) -I$(srcdir):. $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
|
||||
fi
|
||||
|
||||
# Clean
|
||||
|
|
|
|||
32
Examples/test-suite/ruby/li_boost_shared_ptr_bits_runme.rb
Normal file
32
Examples/test-suite/ruby/li_boost_shared_ptr_bits_runme.rb
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
require 'li_boost_shared_ptr_bits'
|
||||
require 'swig_gc'
|
||||
|
||||
v = Li_boost_shared_ptr_bits::VectorIntHolder.new()
|
||||
v.push(Li_boost_shared_ptr_bits::IntHolder.new(11))
|
||||
v.push(Li_boost_shared_ptr_bits::IntHolder.new(22))
|
||||
v.push(Li_boost_shared_ptr_bits::IntHolder.new(33))
|
||||
|
||||
sum = Li_boost_shared_ptr_bits::sum(v)
|
||||
if (sum != 66)
|
||||
raise RuntimeError, "sum is wrong"
|
||||
end
|
||||
|
||||
hidden = Li_boost_shared_ptr_bits::HiddenDestructor.create()
|
||||
GC.track_class = Li_boost_shared_ptr_bits::HiddenPrivateDestructor
|
||||
GC.stats if $VERBOSE
|
||||
hidden = nil
|
||||
GC.start
|
||||
|
||||
hiddenPrivate = Li_boost_shared_ptr_bits::HiddenPrivateDestructor.create()
|
||||
if (Li_boost_shared_ptr_bits::HiddenPrivateDestructor.DeleteCount != 0)
|
||||
# GC doesn't always run
|
||||
# raise RuntimeError, "Count should be zero"
|
||||
end
|
||||
|
||||
GC.stats if $VERBOSE
|
||||
hiddenPrivate = nil
|
||||
GC.start
|
||||
if (Li_boost_shared_ptr_bits::HiddenPrivateDestructor.DeleteCount != 1)
|
||||
# GC doesn't always run
|
||||
# raise RuntimeError, "Count should be one"
|
||||
end
|
||||
614
Examples/test-suite/ruby/li_boost_shared_ptr_runme.rb
Normal file
614
Examples/test-suite/ruby/li_boost_shared_ptr_runme.rb
Normal file
|
|
@ -0,0 +1,614 @@
|
|||
require 'li_boost_shared_ptr'
|
||||
require 'swig_gc'
|
||||
|
||||
#debug = $VERBOSE
|
||||
debug = false
|
||||
|
||||
# simple shared_ptr usage - created in C++
|
||||
|
||||
|
||||
class Li_boost_shared_ptr_runme
|
||||
|
||||
def main(debug)
|
||||
if (debug)
|
||||
puts "Started"
|
||||
end
|
||||
|
||||
Li_boost_shared_ptr::debug_shared = debug
|
||||
|
||||
# Change loop count to run for a long time to monitor memory
|
||||
loopCount = 1 # 5000
|
||||
1.upto(loopCount) do
|
||||
self.runtest()
|
||||
end
|
||||
|
||||
# Expect 1 instance - the one global variable (GlobalValue)
|
||||
GC.track_class = Li_boost_shared_ptr::Klass
|
||||
invokeGC("Final GC")
|
||||
|
||||
# Actual count is 3 due to memory leaks calling rb_raise in the call to Li_boost_shared_ptr::valuetest(nil)
|
||||
# as setjmp/longjmp are used thereby failing to call destructors of Klass instances on the stack in _wrap_valuetest
|
||||
# This is a generic problem in Ruby wrappers, not shared_ptr specific
|
||||
# expectedCount = 1
|
||||
expectedCount = 3
|
||||
actualCount = Li_boost_shared_ptr::Klass.getTotal_count()
|
||||
if (actualCount != expectedCount)
|
||||
# raise RuntimeError, "GC failed to run (li_boost_shared_ptr). Expected count: #{expectedCount} Actual count: #{actualCount}"
|
||||
puts "GC failed to run (li_boost_shared_ptr). Expected count: #{expectedCount} Actual count: #{actualCount}"
|
||||
end
|
||||
|
||||
wrapper_count = Li_boost_shared_ptr::shared_ptr_wrapper_count()
|
||||
if (wrapper_count != Li_boost_shared_ptr.NOT_COUNTING)
|
||||
# Expect 1 instance - the one global variable (GlobalSmartValue)
|
||||
if (wrapper_count != 1)
|
||||
raise RuntimeError, "shared_ptr wrapper count=#{wrapper_count}"
|
||||
end
|
||||
end
|
||||
|
||||
if (debug)
|
||||
puts "Finished"
|
||||
end
|
||||
end
|
||||
|
||||
def invokeGC(debug_msg)
|
||||
puts "invokeGC #{debug_msg} start" if $VERBOSE
|
||||
GC.stats if $VERBOSE
|
||||
GC.start
|
||||
puts "invokeGC #{debug_msg} end" if $VERBOSE
|
||||
end
|
||||
|
||||
def runtest
|
||||
# simple shared_ptr usage - created in C++
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
val = k.getValue()
|
||||
self.verifyValue("me oh my", val)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
# simple shared_ptr usage - not created in C++
|
||||
k = Li_boost_shared_ptr::factorycreate()
|
||||
val = k.getValue()
|
||||
self.verifyValue("factorycreate", val)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
# pass by shared_ptr
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::smartpointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my smartpointertest", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# pass by shared_ptr pointer
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::smartpointerpointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my smartpointerpointertest", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# pass by shared_ptr reference
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::smartpointerreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my smartpointerreftest", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# pass by shared_ptr pointer reference
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::smartpointerpointerreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my smartpointerpointerreftest", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# const pass by shared_ptr
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::constsmartpointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# const pass by shared_ptr pointer
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::constsmartpointerpointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# const pass by shared_ptr reference
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::constsmartpointerreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# pass by value
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::valuetest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my valuetest", val)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# pass by pointer
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::pointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my pointertest", val)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# pass by reference
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::reftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my reftest", val)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# pass by pointer reference
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::pointerreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my pointerreftest", val)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# null tests
|
||||
k = nil
|
||||
|
||||
if (Li_boost_shared_ptr::smartpointertest(k) != nil)
|
||||
raise RuntimeError, "return was not null"
|
||||
end
|
||||
|
||||
if (Li_boost_shared_ptr::smartpointerpointertest(k) != nil)
|
||||
raise RuntimeError, "return was not null"
|
||||
end
|
||||
|
||||
if (Li_boost_shared_ptr::smartpointerreftest(k) != nil)
|
||||
raise RuntimeError, "return was not null"
|
||||
end
|
||||
|
||||
if (Li_boost_shared_ptr::smartpointerpointerreftest(k) != nil)
|
||||
raise RuntimeError, "return was not null"
|
||||
end
|
||||
|
||||
if (Li_boost_shared_ptr::nullsmartpointerpointertest(nil) != "null pointer")
|
||||
raise RuntimeError, "not null smartpointer pointer"
|
||||
end
|
||||
|
||||
begin
|
||||
Li_boost_shared_ptr::valuetest(k)
|
||||
raise RuntimeError, "Failed to catch null pointer"
|
||||
rescue ArgumentError
|
||||
end
|
||||
|
||||
if (Li_boost_shared_ptr::pointertest(k) != nil)
|
||||
raise RuntimeError, "return was not null"
|
||||
end
|
||||
|
||||
begin
|
||||
Li_boost_shared_ptr::reftest(k)
|
||||
raise RuntimeError, "Failed to catch null pointer"
|
||||
rescue ArgumentError
|
||||
end
|
||||
|
||||
# $owner
|
||||
k = Li_boost_shared_ptr::pointerownertest()
|
||||
val = k.getValue()
|
||||
self.verifyValue("pointerownertest", val)
|
||||
self.verifyCount(1, k)
|
||||
k = Li_boost_shared_ptr::smartpointerpointerownertest()
|
||||
val = k.getValue()
|
||||
self.verifyValue("smartpointerpointerownertest", val)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
# //////////////////////////////// Derived class //////////////////////
|
||||
# derived pass by shared_ptr
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::derivedsmartptrtest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my derivedsmartptrtest-Derived", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# derived pass by shared_ptr pointer
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::derivedsmartptrpointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my derivedsmartptrpointertest-Derived", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# derived pass by shared_ptr ref
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::derivedsmartptrreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my derivedsmartptrreftest-Derived", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# derived pass by shared_ptr pointer ref
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::derivedsmartptrpointerreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# derived pass by pointer
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::derivedpointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my derivedpointertest-Derived", val)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# derived pass by ref
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::derivedreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my derivedreftest-Derived", val)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# //////////////////////////////// Derived and base class mixed ///////
|
||||
# pass by shared_ptr (mixed)
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::smartpointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my smartpointertest-Derived", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# pass by shared_ptr pointer (mixed)
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::smartpointerpointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my smartpointerpointertest-Derived", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# pass by shared_ptr reference (mixed)
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::smartpointerreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my smartpointerreftest-Derived", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# pass by shared_ptr pointer reference (mixed)
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::smartpointerpointerreftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my smartpointerpointerreftest-Derived", val)
|
||||
self.verifyCount(2, k)
|
||||
self.verifyCount(2, kret)
|
||||
|
||||
# pass by value (mixed)
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::valuetest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my valuetest", val) # note slicing
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# pass by pointer (mixed)
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::pointertest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my pointertest-Derived", val)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# pass by ref (mixed)
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
kret = Li_boost_shared_ptr::reftest(k)
|
||||
val = kret.getValue()
|
||||
self.verifyValue("me oh my reftest-Derived", val)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyCount(1, kret)
|
||||
|
||||
# //////////////////////////////// Overloading tests //////////////////
|
||||
# Base class
|
||||
k = Li_boost_shared_ptr::Klass.new("me oh my")
|
||||
self.verifyValue(Li_boost_shared_ptr::overload_rawbyval(k), "rawbyval")
|
||||
self.verifyValue(Li_boost_shared_ptr::overload_rawbyref(k), "rawbyref")
|
||||
self.verifyValue(Li_boost_shared_ptr::overload_rawbyptr(k), "rawbyptr")
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_rawbyptrref(k), "rawbyptrref")
|
||||
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_smartbyval(k), "smartbyval")
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_smartbyref(k), "smartbyref")
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_smartbyptr(k), "smartbyptr")
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_smartbyptrref(k), "smartbyptrref")
|
||||
|
||||
# Derived class
|
||||
k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
|
||||
self.verifyValue(Li_boost_shared_ptr::overload_rawbyval(k), "rawbyval")
|
||||
self.verifyValue(Li_boost_shared_ptr::overload_rawbyref(k), "rawbyref")
|
||||
self.verifyValue(Li_boost_shared_ptr::overload_rawbyptr(k), "rawbyptr")
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_rawbyptrref(k), "rawbyptrref")
|
||||
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_smartbyval(k), "smartbyval")
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_smartbyref(k), "smartbyref")
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_smartbyptr(k), "smartbyptr")
|
||||
self.verifyValue(
|
||||
Li_boost_shared_ptr::overload_smartbyptrref(k), "smartbyptrref")
|
||||
|
||||
# 3rd derived class
|
||||
k = Li_boost_shared_ptr::Klass3rdDerived.new("me oh my")
|
||||
val = k.getValue()
|
||||
self.verifyValue("me oh my-3rdDerived", val)
|
||||
self.verifyCount(1, k)
|
||||
val = Li_boost_shared_ptr::test3rdupcast(k)
|
||||
self.verifyValue("me oh my-3rdDerived", val)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
# //////////////////////////////// Member variables ///////////////////
|
||||
# smart pointer by value
|
||||
m = Li_boost_shared_ptr::MemberVariables.new()
|
||||
k = Li_boost_shared_ptr::Klass.new("smart member value")
|
||||
m.SmartMemberValue = k
|
||||
val = k.getValue()
|
||||
self.verifyValue("smart member value", val)
|
||||
self.verifyCount(2, k)
|
||||
|
||||
kmember = m.SmartMemberValue
|
||||
val = kmember.getValue()
|
||||
self.verifyValue("smart member value", val)
|
||||
self.verifyCount(3, kmember)
|
||||
self.verifyCount(3, k)
|
||||
|
||||
GC.track_class = Li_boost_shared_ptr::MemberVariables
|
||||
m = nil
|
||||
invokeGC("m = nil (A)")
|
||||
|
||||
self.verifyCount(2, kmember)
|
||||
self.verifyCount(2, k)
|
||||
|
||||
# smart pointer by pointer
|
||||
m = Li_boost_shared_ptr::MemberVariables.new()
|
||||
k = Li_boost_shared_ptr::Klass.new("smart member pointer")
|
||||
m.SmartMemberPointer = k
|
||||
val = k.getValue()
|
||||
self.verifyValue("smart member pointer", val)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
kmember = m.SmartMemberPointer
|
||||
val = kmember.getValue()
|
||||
self.verifyValue("smart member pointer", val)
|
||||
self.verifyCount(2, kmember)
|
||||
self.verifyCount(2, k)
|
||||
|
||||
m = nil
|
||||
invokeGC("m = nil (B)")
|
||||
|
||||
self.verifyCount(2, kmember)
|
||||
self.verifyCount(2, k)
|
||||
|
||||
# smart pointer by reference
|
||||
m = Li_boost_shared_ptr::MemberVariables.new()
|
||||
k = Li_boost_shared_ptr::Klass.new("smart member reference")
|
||||
m.SmartMemberReference = k
|
||||
val = k.getValue()
|
||||
self.verifyValue("smart member reference", val)
|
||||
self.verifyCount(2, k)
|
||||
|
||||
kmember = m.SmartMemberReference
|
||||
val = kmember.getValue()
|
||||
self.verifyValue("smart member reference", val)
|
||||
self.verifyCount(3, kmember)
|
||||
self.verifyCount(3, k)
|
||||
|
||||
# The C++ reference refers to SmartMemberValue...
|
||||
kmemberVal = m.SmartMemberValue
|
||||
val = kmember.getValue()
|
||||
self.verifyValue("smart member reference", val)
|
||||
self.verifyCount(4, kmemberVal)
|
||||
self.verifyCount(4, kmember)
|
||||
self.verifyCount(4, k)
|
||||
|
||||
m = nil
|
||||
invokeGC("m = nil (C)")
|
||||
|
||||
|
||||
self.verifyCount(3, kmemberVal)
|
||||
self.verifyCount(3, kmember)
|
||||
self.verifyCount(3, k)
|
||||
|
||||
# plain by value
|
||||
m = Li_boost_shared_ptr::MemberVariables.new()
|
||||
k = Li_boost_shared_ptr::Klass.new("plain member value")
|
||||
m.MemberValue = k
|
||||
val = k.getValue()
|
||||
self.verifyValue("plain member value", val)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
kmember = m.MemberValue
|
||||
val = kmember.getValue()
|
||||
self.verifyValue("plain member value", val)
|
||||
self.verifyCount(1, kmember)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
m = nil
|
||||
invokeGC("m = nil (D)")
|
||||
|
||||
self.verifyCount(1, kmember)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
# plain by pointer
|
||||
m = Li_boost_shared_ptr::MemberVariables.new()
|
||||
k = Li_boost_shared_ptr::Klass.new("plain member pointer")
|
||||
m.MemberPointer = k
|
||||
val = k.getValue()
|
||||
self.verifyValue("plain member pointer", val)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
kmember = m.MemberPointer
|
||||
val = kmember.getValue()
|
||||
self.verifyValue("plain member pointer", val)
|
||||
self.verifyCount(1, kmember)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
m = nil
|
||||
invokeGC("m = nil (E)")
|
||||
|
||||
self.verifyCount(1, kmember)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
# plain by reference
|
||||
m = Li_boost_shared_ptr::MemberVariables.new()
|
||||
k = Li_boost_shared_ptr::Klass.new("plain member reference")
|
||||
m.MemberReference = k
|
||||
val = k.getValue()
|
||||
self.verifyValue("plain member reference", val)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
kmember = m.MemberReference
|
||||
val = kmember.getValue()
|
||||
self.verifyValue("plain member reference", val)
|
||||
self.verifyCount(1, kmember)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
m = nil
|
||||
invokeGC("m = nil (F)")
|
||||
|
||||
self.verifyCount(1, kmember)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
# null member variables
|
||||
m = Li_boost_shared_ptr::MemberVariables.new()
|
||||
|
||||
# shared_ptr by value
|
||||
k = m.SmartMemberValue
|
||||
if (k != nil)
|
||||
raise RuntimeError, "expected null"
|
||||
end
|
||||
m.SmartMemberValue = nil
|
||||
k = m.SmartMemberValue
|
||||
if (k != nil)
|
||||
raise RuntimeError, "expected null"
|
||||
end
|
||||
self.verifyCount(0, k)
|
||||
|
||||
# plain by value
|
||||
begin
|
||||
m.MemberValue = nil
|
||||
raise RuntimeError, "Failed to catch null pointer"
|
||||
rescue ArgumentError
|
||||
end
|
||||
|
||||
# ////////////////////////////////// Global variables /////////////////
|
||||
# smart pointer
|
||||
kglobal = Li_boost_shared_ptr.GlobalSmartValue
|
||||
if (kglobal != nil)
|
||||
raise RuntimeError, "expected null"
|
||||
end
|
||||
|
||||
k = Li_boost_shared_ptr::Klass.new("smart global value")
|
||||
Li_boost_shared_ptr.GlobalSmartValue = k
|
||||
self.verifyCount(2, k)
|
||||
|
||||
kglobal = Li_boost_shared_ptr.GlobalSmartValue
|
||||
val = kglobal.getValue()
|
||||
self.verifyValue("smart global value", val)
|
||||
self.verifyCount(3, kglobal)
|
||||
self.verifyCount(3, k)
|
||||
self.verifyValue(
|
||||
"smart global value", Li_boost_shared_ptr.GlobalSmartValue.getValue())
|
||||
Li_boost_shared_ptr.GlobalSmartValue = nil
|
||||
|
||||
# plain value
|
||||
k = Li_boost_shared_ptr::Klass.new("global value")
|
||||
Li_boost_shared_ptr.GlobalValue = k
|
||||
self.verifyCount(1, k)
|
||||
|
||||
kglobal = Li_boost_shared_ptr.GlobalValue
|
||||
val = kglobal.getValue()
|
||||
self.verifyValue("global value", val)
|
||||
self.verifyCount(1, kglobal)
|
||||
self.verifyCount(1, k)
|
||||
self.verifyValue(
|
||||
"global value", Li_boost_shared_ptr.GlobalValue.getValue())
|
||||
|
||||
begin
|
||||
Li_boost_shared_ptr.GlobalValue = nil
|
||||
raise RuntimeError, "Failed to catch null pointer"
|
||||
rescue ArgumentError
|
||||
end
|
||||
|
||||
# plain pointer
|
||||
kglobal = Li_boost_shared_ptr.GlobalPointer
|
||||
if (kglobal != nil)
|
||||
raise RuntimeError, "expected null"
|
||||
end
|
||||
|
||||
k = Li_boost_shared_ptr::Klass.new("global pointer")
|
||||
Li_boost_shared_ptr.GlobalPointer = k
|
||||
self.verifyCount(1, k)
|
||||
|
||||
kglobal = Li_boost_shared_ptr.GlobalPointer
|
||||
val = kglobal.getValue()
|
||||
self.verifyValue("global pointer", val)
|
||||
self.verifyCount(1, kglobal)
|
||||
self.verifyCount(1, k)
|
||||
Li_boost_shared_ptr.GlobalPointer = nil
|
||||
|
||||
# plain reference
|
||||
|
||||
k = Li_boost_shared_ptr::Klass.new("global reference")
|
||||
Li_boost_shared_ptr.GlobalReference = k
|
||||
self.verifyCount(1, k)
|
||||
|
||||
kglobal = Li_boost_shared_ptr.GlobalReference
|
||||
val = kglobal.getValue()
|
||||
self.verifyValue("global reference", val)
|
||||
self.verifyCount(1, kglobal)
|
||||
self.verifyCount(1, k)
|
||||
|
||||
begin
|
||||
Li_boost_shared_ptr.GlobalReference = nil
|
||||
raise RuntimeError, "Failed to catch null pointer"
|
||||
rescue ArgumentError
|
||||
end
|
||||
|
||||
# ////////////////////////////////// Templates ////////////////////////
|
||||
pid = Li_boost_shared_ptr::PairIntDouble.new(10, 20.2)
|
||||
if (pid.baseVal1 != 20 or pid.baseVal2 != 40.4)
|
||||
raise RuntimeError, "Base values wrong"
|
||||
end
|
||||
if (pid.val1 != 10 or pid.val2 != 20.2)
|
||||
raise RuntimeError, "Derived Values wrong"
|
||||
end
|
||||
end
|
||||
|
||||
def verifyValue(expected, got)
|
||||
if (expected != got)
|
||||
raise RuntimeError, "verify value failed. Expected: #{expected} Got: #{got}"
|
||||
end
|
||||
end
|
||||
|
||||
def verifyCount(expected, k)
|
||||
got = Li_boost_shared_ptr::use_count(k)
|
||||
if (expected != got)
|
||||
puts "skipped verifyCount expect/got: #{expected}/#{got}"
|
||||
# raise RuntimeError, "verify use_count failed. Expected: #{expected} Got: #{got}"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
runme = Li_boost_shared_ptr_runme.new()
|
||||
runme.main(debug)
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
require 'li_boost_shared_ptr_template'
|
||||
|
||||
begin
|
||||
b = Li_boost_shared_ptr_template::BaseINTEGER.new()
|
||||
d = Li_boost_shared_ptr_template::DerivedINTEGER.new()
|
||||
if (b.bar() != 1)
|
||||
raise RuntimeError("test 1")
|
||||
end
|
||||
if (d.bar() != 2)
|
||||
raise RuntimeError("test 2")
|
||||
end
|
||||
if (Li_boost_shared_ptr_template.bar_getter(b) != 1)
|
||||
raise RuntimeError("test 3")
|
||||
end
|
||||
# Needs fixing as it does for Python
|
||||
# if (Li_boost_shared_ptr_template.bar_getter(d) != 2)
|
||||
# raise RuntimeError("test 4")
|
||||
# end
|
||||
end
|
||||
|
||||
begin
|
||||
b = Li_boost_shared_ptr_template::BaseDefaultInt.new()
|
||||
d = Li_boost_shared_ptr_template::DerivedDefaultInt.new()
|
||||
d2 = Li_boost_shared_ptr_template::DerivedDefaultInt2.new()
|
||||
if (b.bar2() != 3)
|
||||
raise RuntimeError("test 5")
|
||||
end
|
||||
if (d.bar2() != 4)
|
||||
raise RuntimeError("test 6")
|
||||
end
|
||||
if (d2.bar2() != 4)
|
||||
raise RuntimeError("test 6")
|
||||
end
|
||||
if (Li_boost_shared_ptr_template.bar2_getter(b) != 3)
|
||||
raise RuntimeError("test 7")
|
||||
end
|
||||
# Needs fixing as it does for Python
|
||||
# if (Li_boost_shared_ptr_template.bar2_getter(d) != 4)
|
||||
# raise RuntimeError("test 8")
|
||||
# end
|
||||
# if (Li_boost_shared_ptr_template.bar2_getter(d2) != 4)
|
||||
# raise RuntimeError("test 8")
|
||||
# end
|
||||
end
|
||||
|
||||
|
|
@ -41,7 +41,7 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
if (!argp) {
|
||||
%argument_nullref("$type", $symname, $argnum);
|
||||
%variable_nullref("$type", "$name");
|
||||
} else {
|
||||
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
@ -126,7 +126,9 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
|
||||
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
|
||||
if (!argp) {
|
||||
%variable_nullref("$type", "$name");
|
||||
}
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
if (!argp) {
|
||||
%argument_nullref("$type", $symname, $argnum);
|
||||
%variable_nullref("$type", "$name");
|
||||
} else {
|
||||
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
@ -137,7 +137,9 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
|
||||
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
|
||||
if (!argp) {
|
||||
%variable_nullref("$type", "$name");
|
||||
}
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
if (!argp) {
|
||||
%argument_nullref("$type", $symname, $argnum);
|
||||
%variable_nullref("$type", "$name");
|
||||
} else {
|
||||
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
@ -124,7 +124,9 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
|
||||
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
|
||||
if (!argp) {
|
||||
%variable_nullref("$type", "$name");
|
||||
}
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
|
|||
323
Lib/ruby/boost_shared_ptr.i
Normal file
323
Lib/ruby/boost_shared_ptr.i
Normal file
|
|
@ -0,0 +1,323 @@
|
|||
%include <shared_ptr.i>
|
||||
|
||||
// Set SHARED_PTR_DISOWN to $disown if required, for example
|
||||
// #define SHARED_PTR_DISOWN $disown
|
||||
#if !defined(SHARED_PTR_DISOWN)
|
||||
#define SHARED_PTR_DISOWN 0
|
||||
#endif
|
||||
|
||||
%fragment("SWIG_null_deleter_python", "header", fragment="SWIG_null_deleter") {
|
||||
%#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT
|
||||
}
|
||||
|
||||
// Language specific macro implementing all the customisations for handling the smart pointer
|
||||
%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
|
||||
|
||||
// %naturalvar is as documented for member variables
|
||||
%naturalvar TYPE;
|
||||
%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
|
||||
|
||||
// destructor wrapper customisation
|
||||
%feature("unref") TYPE
|
||||
%{(void)arg1;
|
||||
delete reinterpret_cast< SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > * >(self);%}
|
||||
|
||||
// Typemap customisations...
|
||||
|
||||
// plain value
|
||||
%typemap(in) CONST TYPE (void *argp, int res = 0) {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%argument_fail(res, "$type", $symname, $argnum);
|
||||
}
|
||||
if (!argp) {
|
||||
%argument_nullref("$type", $symname, $argnum);
|
||||
} else {
|
||||
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
}
|
||||
}
|
||||
%typemap(out) CONST TYPE {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
|
||||
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
%typemap(varin) CONST TYPE {
|
||||
void *argp = 0;
|
||||
swig_ruby_owntype newmem = {0};
|
||||
int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
if (!argp) {
|
||||
%variable_nullref("$type", "$name");
|
||||
} else {
|
||||
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
}
|
||||
}
|
||||
%typemap(varout) CONST TYPE {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
|
||||
%set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
// plain pointer
|
||||
// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
|
||||
%typemap(in) CONST TYPE * (void *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%argument_fail(res, "$type", $symname, $argnum);
|
||||
}
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
$1 = %const_cast(tempshared.get(), $1_ltype);
|
||||
} else {
|
||||
smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
$1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE * {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
|
||||
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
%typemap(varin) CONST TYPE * {
|
||||
void *argp = 0;
|
||||
swig_ruby_owntype newmem = {0};
|
||||
int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
$1 = %const_cast(tempshared.get(), $1_ltype);
|
||||
} else {
|
||||
smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
$1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
|
||||
}
|
||||
}
|
||||
%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE * {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
|
||||
%set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
// plain reference
|
||||
%typemap(in) CONST TYPE & (void *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%argument_fail(res, "$type", $symname, $argnum);
|
||||
}
|
||||
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
$1 = %const_cast(tempshared.get(), $1_ltype);
|
||||
} else {
|
||||
$1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
|
||||
}
|
||||
}
|
||||
%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE & {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
|
||||
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
%typemap(varin) CONST TYPE & {
|
||||
void *argp = 0;
|
||||
swig_ruby_owntype newmem = {0};
|
||||
int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
|
||||
if (!argp) {
|
||||
%variable_nullref("$type", "$name");
|
||||
}
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
$1 = *%const_cast(tempshared.get(), $1_ltype);
|
||||
} else {
|
||||
$1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
|
||||
}
|
||||
}
|
||||
%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE & {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
|
||||
%set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
// plain pointer by reference
|
||||
// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
|
||||
%typemap(in) TYPE *CONST& (void *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%argument_fail(res, "$type", $symname, $argnum);
|
||||
}
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
temp = %const_cast(tempshared.get(), $*1_ltype);
|
||||
} else {
|
||||
temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
|
||||
}
|
||||
$1 = &temp;
|
||||
}
|
||||
%typemap(out, fragment="SWIG_null_deleter_python") TYPE *CONST& {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
|
||||
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
%typemap(varin) TYPE *CONST& %{
|
||||
#error "varin typemap not implemented"
|
||||
%}
|
||||
%typemap(varout) TYPE *CONST& %{
|
||||
#error "varout typemap not implemented"
|
||||
%}
|
||||
|
||||
// shared_ptr by value
|
||||
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%argument_fail(res, "$type", $symname, $argnum);
|
||||
}
|
||||
if (argp) $1 = *(%reinterpret_cast(argp, $<ype));
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $<ype);
|
||||
}
|
||||
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
|
||||
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
void *argp = 0;
|
||||
int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
$1 = argp ? *(%reinterpret_cast(argp, $<ype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $<ype);
|
||||
}
|
||||
%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
|
||||
%set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
// shared_ptr by reference
|
||||
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%argument_fail(res, "$type", $symname, $argnum);
|
||||
}
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) {
|
||||
if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
|
||||
delete %reinterpret_cast(argp, $ltype);
|
||||
$1 = &tempshared;
|
||||
} else {
|
||||
$1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
|
||||
}
|
||||
}
|
||||
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
|
||||
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
|
||||
#error "varin typemap not implemented"
|
||||
%}
|
||||
%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
|
||||
#error "varout typemap not implemented"
|
||||
%}
|
||||
|
||||
// shared_ptr by pointer
|
||||
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%argument_fail(res, "$type", $symname, $argnum);
|
||||
}
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) {
|
||||
if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
|
||||
delete %reinterpret_cast(argp, $ltype);
|
||||
$1 = &tempshared;
|
||||
} else {
|
||||
$1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
|
||||
}
|
||||
}
|
||||
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
|
||||
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
if ($owner) delete $1;
|
||||
}
|
||||
|
||||
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
|
||||
#error "varin typemap not implemented"
|
||||
%}
|
||||
%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
|
||||
#error "varout typemap not implemented"
|
||||
%}
|
||||
|
||||
// shared_ptr by pointer reference
|
||||
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
|
||||
swig_ruby_owntype newmem = {0};
|
||||
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
|
||||
if (!SWIG_IsOK(res)) {
|
||||
%argument_fail(res, "$type", $symname, $argnum);
|
||||
}
|
||||
if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
|
||||
if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
|
||||
temp = &tempshared;
|
||||
$1 = &temp;
|
||||
}
|
||||
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
|
||||
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
|
||||
}
|
||||
|
||||
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
|
||||
#error "varin typemap not implemented"
|
||||
%}
|
||||
%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
|
||||
#error "varout typemap not implemented"
|
||||
%}
|
||||
|
||||
// Typecheck typemaps
|
||||
// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting
|
||||
// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
|
||||
%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1)
|
||||
TYPE CONST,
|
||||
TYPE CONST &,
|
||||
TYPE CONST *,
|
||||
TYPE *CONST&,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
|
||||
int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
|
||||
$1 = SWIG_CheckState(res);
|
||||
}
|
||||
|
||||
|
||||
// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug
|
||||
%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
|
||||
#error "typemaps for $1_type not available"
|
||||
%}
|
||||
%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
|
||||
#error "typemaps for $1_type not available"
|
||||
%}
|
||||
|
||||
|
||||
%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
|
||||
|
||||
|
||||
%enddef
|
||||
|
|
@ -29,8 +29,9 @@ namespace Swig {
|
|||
virtual ~GCItem() {
|
||||
}
|
||||
|
||||
virtual ruby_owntype get_own() const {
|
||||
return 0;
|
||||
virtual swig_ruby_owntype get_own() const {
|
||||
swig_ruby_owntype own = {0};
|
||||
return own;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -72,18 +73,18 @@ namespace Swig {
|
|||
};
|
||||
|
||||
struct GCItem_Object : GCItem {
|
||||
GCItem_Object(ruby_owntype own) : _own(own) {
|
||||
GCItem_Object(swig_ruby_owntype own) : _own(own) {
|
||||
}
|
||||
|
||||
virtual ~GCItem_Object() {
|
||||
}
|
||||
|
||||
ruby_owntype get_own() const {
|
||||
swig_ruby_owntype get_own() const {
|
||||
return _own;
|
||||
}
|
||||
|
||||
private:
|
||||
ruby_owntype _own;
|
||||
swig_ruby_owntype _own;
|
||||
};
|
||||
|
||||
template <typename Type>
|
||||
|
|
@ -323,20 +324,20 @@ namespace Swig {
|
|||
}
|
||||
}
|
||||
|
||||
void swig_acquire_ownership_obj(void *vptr, ruby_owntype own) const {
|
||||
if (vptr && own) {
|
||||
void swig_acquire_ownership_obj(void *vptr, swig_ruby_owntype own) const {
|
||||
if (vptr && own.datafree) {
|
||||
SWIG_GUARD(swig_mutex_own);
|
||||
swig_owner[vptr] = new GCItem_Object(own);
|
||||
}
|
||||
}
|
||||
|
||||
ruby_owntype swig_release_ownership(void *vptr) const {
|
||||
ruby_owntype own = 0;
|
||||
swig_ruby_owntype swig_release_ownership(void *vptr) const {
|
||||
swig_ruby_owntype own = {0};
|
||||
if (vptr) {
|
||||
SWIG_GUARD(swig_mutex_own);
|
||||
swig_ownership_map::iterator iter = swig_owner.find(vptr);
|
||||
if (iter != swig_owner.end()) {
|
||||
own = iter->second->get_own();
|
||||
own.datafree = iter->second->get_own().datafree;
|
||||
swig_owner.erase(iter);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
|
||||
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
|
||||
#define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
|
||||
#define swig_owntype ruby_owntype
|
||||
#define swig_owntype swig_ruby_owntype
|
||||
|
||||
/* for raw packed data */
|
||||
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
|
||||
|
|
@ -238,22 +238,24 @@ SWIG_Ruby_MangleStr(VALUE obj)
|
|||
}
|
||||
|
||||
/* Acquire a pointer value */
|
||||
typedef void (*ruby_owntype)(void*);
|
||||
typedef struct {
|
||||
void (*datafree)(void *);
|
||||
int own;
|
||||
} swig_ruby_owntype;
|
||||
|
||||
SWIGRUNTIME ruby_owntype
|
||||
SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
|
||||
SWIGRUNTIME swig_ruby_owntype
|
||||
SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
|
||||
swig_ruby_owntype oldown = {0};
|
||||
if (obj) {
|
||||
ruby_owntype oldown = RDATA(obj)->dfree;
|
||||
RDATA(obj)->dfree = own;
|
||||
return oldown;
|
||||
} else {
|
||||
return 0;
|
||||
oldown.datafree = RDATA(obj)->dfree;
|
||||
RDATA(obj)->dfree = own.datafree;
|
||||
}
|
||||
return oldown;
|
||||
}
|
||||
|
||||
/* Convert a pointer value */
|
||||
SWIGRUNTIME int
|
||||
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
|
||||
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
|
||||
{
|
||||
char *c;
|
||||
swig_cast_info *tc;
|
||||
|
|
@ -261,7 +263,8 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
|
|||
|
||||
/* Grab the pointer */
|
||||
if (NIL_P(obj)) {
|
||||
*ptr = 0;
|
||||
if (ptr)
|
||||
*ptr = 0;
|
||||
return SWIG_OK;
|
||||
} else {
|
||||
if (TYPE(obj) != T_DATA) {
|
||||
|
|
@ -270,7 +273,10 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
|
|||
Data_Get_Struct(obj, void, vptr);
|
||||
}
|
||||
|
||||
if (own) *own = RDATA(obj)->dfree;
|
||||
if (own) {
|
||||
own->datafree = RDATA(obj)->dfree;
|
||||
own->own = 0;
|
||||
}
|
||||
|
||||
/* Check to see if the input object is giving up ownership
|
||||
of the underlying C struct or C++ object. If so then we
|
||||
|
|
@ -299,16 +305,6 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
|
|||
|
||||
/* Do type-checking if type info was provided */
|
||||
if (ty) {
|
||||
if (ty->clientdata) {
|
||||
if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
|
||||
if (vptr == 0) {
|
||||
/* The object has already been deleted */
|
||||
return SWIG_ObjectPreviouslyDeletedError;
|
||||
}
|
||||
*ptr = vptr;
|
||||
return SWIG_OK;
|
||||
}
|
||||
}
|
||||
if ((c = SWIG_MangleStr(obj)) == NULL) {
|
||||
return SWIG_ERROR;
|
||||
}
|
||||
|
|
@ -316,12 +312,27 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
|
|||
if (!tc) {
|
||||
return SWIG_ERROR;
|
||||
} else {
|
||||
int newmemory = 0;
|
||||
*ptr = SWIG_TypeCast(tc, vptr, &newmemory);
|
||||
assert(!newmemory); /* newmemory handling not yet implemented */
|
||||
if (vptr == 0) {
|
||||
/* The object has already been deleted */
|
||||
return SWIG_ObjectPreviouslyDeletedError;
|
||||
}
|
||||
if (ptr) {
|
||||
if (tc->type == ty) {
|
||||
*ptr = vptr;
|
||||
} else {
|
||||
int newmemory = 0;
|
||||
*ptr = SWIG_TypeCast(tc, vptr, &newmemory);
|
||||
if (newmemory == SWIG_CAST_NEW_MEMORY) {
|
||||
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
|
||||
if (own)
|
||||
own->own = own->own | SWIG_CAST_NEW_MEMORY;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
*ptr = vptr;
|
||||
if (ptr)
|
||||
*ptr = vptr;
|
||||
}
|
||||
|
||||
return SWIG_OK;
|
||||
|
|
|
|||
2
Lib/ruby/std_shared_ptr.i
Normal file
2
Lib/ruby/std_shared_ptr.i
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
#define SWIG_SHARED_PTR_NAMESPACE std
|
||||
%include <boost_shared_ptr.i>
|
||||
|
|
@ -47,7 +47,7 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
if (!argp) {
|
||||
%argument_nullref("$type", $symname, $argnum);
|
||||
%variable_nullref("$type", "$name");
|
||||
} else {
|
||||
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
@ -133,7 +133,9 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
|
||||
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
|
||||
if (!argp) {
|
||||
%variable_nullref("$type", "$name");
|
||||
}
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
|
|||
|
|
@ -57,6 +57,7 @@ extern "C" {
|
|||
|
||||
/* util.c */
|
||||
extern void Swig_cparse_replace_descriptor(String *s);
|
||||
extern SwigType *Swig_cparse_smartptr(Node *n);
|
||||
extern void cparse_normalize_void(Node *);
|
||||
extern Parm *Swig_cparse_parm(String *s);
|
||||
extern ParmList *Swig_cparse_parms(String *s, Node *file_line_node);
|
||||
|
|
|
|||
|
|
@ -70,6 +70,28 @@ void Swig_cparse_replace_descriptor(String *s) {
|
|||
}
|
||||
}
|
||||
|
||||
/* -----------------------------------------------------------------------------
|
||||
* Swig_cparse_smartptr()
|
||||
*
|
||||
* Parse the type in smartptr feature and convert into a SwigType.
|
||||
* Error out if the parsing fails as this is like a parser syntax error.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
SwigType *Swig_cparse_smartptr(Node *n) {
|
||||
SwigType *smart = 0;
|
||||
String *smartptr = Getattr(n, "feature:smartptr");
|
||||
if (smartptr) {
|
||||
SwigType *cpt = Swig_cparse_type(smartptr);
|
||||
if (cpt) {
|
||||
smart = SwigType_typedef_resolve_all(cpt);
|
||||
Delete(cpt);
|
||||
} else {
|
||||
Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, SwigType_namestr(Getattr(n, "name")));
|
||||
}
|
||||
}
|
||||
return smart;
|
||||
}
|
||||
|
||||
/* -----------------------------------------------------------------------------
|
||||
* cparse_normalize_void()
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1854,8 +1854,8 @@ public:
|
|||
|
||||
// Add code to do C++ casting to base class (only for classes in an inheritance hierarchy)
|
||||
if (derived) {
|
||||
String *smartptr = Getattr(n, "feature:smartptr");
|
||||
String *upcast_method = Swig_name_member(getNSpace(), getClassPrefix(), smartptr != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
|
||||
SwigType *smart = Swig_cparse_smartptr(n);
|
||||
String *upcast_method = Swig_name_member(getNSpace(), getClassPrefix(), smart != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
|
||||
String *wname = Swig_name_wrapper(upcast_method);
|
||||
|
||||
Printv(imclass_cppcasts_code, "\n [global::System.Runtime.InteropServices.DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
|
||||
|
|
@ -1863,29 +1863,22 @@ public:
|
|||
|
||||
Replaceall(imclass_cppcasts_code, "$csclassname", proxy_class_name);
|
||||
|
||||
if (smartptr) {
|
||||
SwigType *spt = Swig_cparse_type(smartptr);
|
||||
if (spt) {
|
||||
SwigType *smart = SwigType_typedef_resolve_all(spt);
|
||||
Delete(spt);
|
||||
SwigType *bsmart = Copy(smart);
|
||||
SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
|
||||
SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
|
||||
Replaceall(bsmart, rclassname, rbaseclass);
|
||||
Delete(rclassname);
|
||||
Delete(rbaseclass);
|
||||
String *smartnamestr = SwigType_namestr(smart);
|
||||
String *bsmartnamestr = SwigType_namestr(bsmart);
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT ", bsmartnamestr, " * SWIGSTDCALL ", wname, "(", smartnamestr, " *jarg1) {\n",
|
||||
" return jarg1 ? new ", bsmartnamestr, "(*jarg1) : 0;\n"
|
||||
"}\n", "\n", NIL);
|
||||
Delete(bsmartnamestr);
|
||||
Delete(smartnamestr);
|
||||
Delete(bsmart);
|
||||
} else {
|
||||
Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, c_classname);
|
||||
}
|
||||
if (smart) {
|
||||
SwigType *bsmart = Copy(smart);
|
||||
SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
|
||||
SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
|
||||
Replaceall(bsmart, rclassname, rbaseclass);
|
||||
Delete(rclassname);
|
||||
Delete(rbaseclass);
|
||||
String *smartnamestr = SwigType_namestr(smart);
|
||||
String *bsmartnamestr = SwigType_namestr(bsmart);
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT ", bsmartnamestr, " * SWIGSTDCALL ", wname, "(", smartnamestr, " *jarg1) {\n",
|
||||
" return jarg1 ? new ", bsmartnamestr, "(*jarg1) : 0;\n"
|
||||
"}\n", "\n", NIL);
|
||||
Delete(bsmartnamestr);
|
||||
Delete(smartnamestr);
|
||||
Delete(bsmart);
|
||||
} else {
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT ", c_baseclass, " * SWIGSTDCALL ", wname, "(", c_classname, " *jarg1) {\n",
|
||||
|
|
@ -1894,6 +1887,7 @@ public:
|
|||
}
|
||||
Delete(wname);
|
||||
Delete(upcast_method);
|
||||
Delete(smart);
|
||||
}
|
||||
Delete(baseclass);
|
||||
}
|
||||
|
|
@ -3469,7 +3463,7 @@ public:
|
|||
Wrapper *code_wrap = NewWrapper();
|
||||
Printf(code_wrap->def, "SWIGEXPORT void SWIGSTDCALL %s(void *objarg", wname);
|
||||
|
||||
if (Len(smartptr)) {
|
||||
if (smartptr) {
|
||||
Printf(code_wrap->code, " %s *obj = (%s *)objarg;\n", smartptr, smartptr);
|
||||
Printf(code_wrap->code, " // Keep a local instance of the smart pointer around while we are using the raw pointer\n");
|
||||
Printf(code_wrap->code, " // Avoids using smart pointer specific API.\n");
|
||||
|
|
|
|||
|
|
@ -3329,45 +3329,33 @@ private:
|
|||
/* ---------------------------------------------------------------------------
|
||||
* D::writeClassUpcast()
|
||||
* --------------------------------------------------------------------------- */
|
||||
void writeClassUpcast(Node *n, const String* d_class_name,
|
||||
String* c_class_name, String* c_base_name) {
|
||||
|
||||
String *smartptr = Getattr(n, "feature:smartptr");
|
||||
String *upcast_name = Swig_name_member(getNSpace(), d_class_name,
|
||||
(smartptr != 0 ? "SmartPtrUpcast" : "Upcast"));
|
||||
void writeClassUpcast(Node *n, const String* d_class_name, String* c_class_name, String* c_base_name) {
|
||||
|
||||
SwigType *smart = Swig_cparse_smartptr(n);
|
||||
String *upcast_name = Swig_name_member(getNSpace(), d_class_name, (smart != 0 ? "SmartPtrUpcast" : "Upcast"));
|
||||
String *upcast_wrapper_name = Swig_name_wrapper(upcast_name);
|
||||
|
||||
writeImDModuleFunction(upcast_name, "void*", "(void* objectRef)",
|
||||
upcast_wrapper_name);
|
||||
|
||||
if (smartptr) {
|
||||
SwigType *spt = Swig_cparse_type(smartptr);
|
||||
if (spt) {
|
||||
SwigType *smart = SwigType_typedef_resolve_all(spt);
|
||||
Delete(spt);
|
||||
SwigType *bsmart = Copy(smart);
|
||||
SwigType *rclassname = SwigType_typedef_resolve_all(c_class_name);
|
||||
SwigType *rbaseclass = SwigType_typedef_resolve_all(c_base_name);
|
||||
Replaceall(bsmart, rclassname, rbaseclass);
|
||||
Delete(rclassname);
|
||||
Delete(rbaseclass);
|
||||
String *smartnamestr = SwigType_namestr(smart);
|
||||
String *bsmartnamestr = SwigType_namestr(bsmart);
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT ", bsmartnamestr, " * ", upcast_wrapper_name,
|
||||
"(", smartnamestr, " *objectRef) {\n",
|
||||
" return objectRef ? new ", bsmartnamestr, "(*objectRef) : 0;\n"
|
||||
"}\n",
|
||||
"\n", NIL);
|
||||
Delete(bsmartnamestr);
|
||||
Delete(smartnamestr);
|
||||
Delete(bsmart);
|
||||
} else {
|
||||
Swig_error(Getfile(n), Getline(n),
|
||||
"Invalid type (%s) in 'smartptr' feature for class %s.\n",
|
||||
smartptr, c_class_name);
|
||||
}
|
||||
if (smart) {
|
||||
SwigType *bsmart = Copy(smart);
|
||||
SwigType *rclassname = SwigType_typedef_resolve_all(c_class_name);
|
||||
SwigType *rbaseclass = SwigType_typedef_resolve_all(c_base_name);
|
||||
Replaceall(bsmart, rclassname, rbaseclass);
|
||||
Delete(rclassname);
|
||||
Delete(rbaseclass);
|
||||
String *smartnamestr = SwigType_namestr(smart);
|
||||
String *bsmartnamestr = SwigType_namestr(bsmart);
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT ", bsmartnamestr, " * ", upcast_wrapper_name,
|
||||
"(", smartnamestr, " *objectRef) {\n",
|
||||
" return objectRef ? new ", bsmartnamestr, "(*objectRef) : 0;\n"
|
||||
"}\n",
|
||||
"\n", NIL);
|
||||
Delete(bsmartnamestr);
|
||||
Delete(smartnamestr);
|
||||
Delete(bsmart);
|
||||
} else {
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT ", c_base_name, " * ", upcast_wrapper_name,
|
||||
|
|
@ -3382,6 +3370,7 @@ private:
|
|||
|
||||
Delete(upcast_name);
|
||||
Delete(upcast_wrapper_name);
|
||||
Delete(smart);
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -1875,40 +1875,33 @@ public:
|
|||
|
||||
// Add code to do C++ casting to base class (only for classes in an inheritance hierarchy)
|
||||
if (derived) {
|
||||
String *smartptr = Getattr(n, "feature:smartptr");
|
||||
String *upcast_method = Swig_name_member(getNSpace(), getClassPrefix(), smartptr != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
|
||||
SwigType *smart = Swig_cparse_smartptr(n);
|
||||
String *upcast_method = Swig_name_member(getNSpace(), getClassPrefix(), smart != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
|
||||
String *jniname = makeValidJniName(upcast_method);
|
||||
String *wname = Swig_name_wrapper(jniname);
|
||||
Printf(imclass_cppcasts_code, " public final static native long %s(long jarg1);\n", upcast_method);
|
||||
if (smartptr) {
|
||||
SwigType *spt = Swig_cparse_type(smartptr);
|
||||
if (spt) {
|
||||
SwigType *smart = SwigType_typedef_resolve_all(spt);
|
||||
Delete(spt);
|
||||
SwigType *bsmart = Copy(smart);
|
||||
SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
|
||||
SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
|
||||
Replaceall(bsmart, rclassname, rbaseclass);
|
||||
Delete(rclassname);
|
||||
Delete(rbaseclass);
|
||||
String *smartnamestr = SwigType_namestr(smart);
|
||||
String *bsmartnamestr = SwigType_namestr(bsmart);
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
|
||||
" jlong baseptr = 0;\n"
|
||||
" ", smartnamestr, " *argp1;\n"
|
||||
" (void)jenv;\n"
|
||||
" (void)jcls;\n"
|
||||
" argp1 = *(", smartnamestr, " **)&jarg1;\n"
|
||||
" *(", bsmartnamestr, " **)&baseptr = argp1 ? new ", bsmartnamestr, "(*argp1) : 0;\n"
|
||||
" return baseptr;\n"
|
||||
"}\n", "\n", NIL);
|
||||
Delete(bsmartnamestr);
|
||||
Delete(smartnamestr);
|
||||
Delete(bsmart);
|
||||
} else {
|
||||
Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, c_classname);
|
||||
}
|
||||
if (smart) {
|
||||
SwigType *bsmart = Copy(smart);
|
||||
SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
|
||||
SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
|
||||
Replaceall(bsmart, rclassname, rbaseclass);
|
||||
Delete(rclassname);
|
||||
Delete(rbaseclass);
|
||||
String *smartnamestr = SwigType_namestr(smart);
|
||||
String *bsmartnamestr = SwigType_namestr(bsmart);
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
|
||||
" jlong baseptr = 0;\n"
|
||||
" ", smartnamestr, " *argp1;\n"
|
||||
" (void)jenv;\n"
|
||||
" (void)jcls;\n"
|
||||
" argp1 = *(", smartnamestr, " **)&jarg1;\n"
|
||||
" *(", bsmartnamestr, " **)&baseptr = argp1 ? new ", bsmartnamestr, "(*argp1) : 0;\n"
|
||||
" return baseptr;\n"
|
||||
"}\n", "\n", NIL);
|
||||
Delete(bsmartnamestr);
|
||||
Delete(smartnamestr);
|
||||
Delete(bsmart);
|
||||
} else {
|
||||
Printv(upcasts_code,
|
||||
"SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
|
||||
|
|
@ -1922,6 +1915,7 @@ public:
|
|||
Delete(wname);
|
||||
Delete(jniname);
|
||||
Delete(upcast_method);
|
||||
Delete(smart);
|
||||
}
|
||||
Delete(baseclass);
|
||||
}
|
||||
|
|
@ -3486,7 +3480,7 @@ public:
|
|||
"SWIGEXPORT void JNICALL Java_%s%s_%s(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, "
|
||||
"jboolean jweak_global) {\n", jnipackage, jni_imclass_name, swig_director_connect_jni);
|
||||
|
||||
if (Len(smartptr)) {
|
||||
if (smartptr) {
|
||||
Printf(code_wrap->code, " %s *obj = *((%s **)&objarg);\n", smartptr, smartptr);
|
||||
Printf(code_wrap->code, " (void)jcls;\n");
|
||||
Printf(code_wrap->code, " // Keep a local instance of the smart pointer around while we are using the raw pointer\n");
|
||||
|
|
|
|||
|
|
@ -966,25 +966,13 @@ public:
|
|||
SwigType *t = Copy(Getattr(n, "name"));
|
||||
SwigType_add_pointer(t);
|
||||
|
||||
String *smartptr = Getattr(n, "feature:smartptr"); // Replace storing a pointer to underlying class with a smart pointer (intended for use with non-intrusive smart pointers)
|
||||
SwigType *smart = 0;
|
||||
if (smartptr) {
|
||||
SwigType *cpt = Swig_cparse_type(smartptr);
|
||||
if (cpt) {
|
||||
smart = SwigType_typedef_resolve_all(cpt);
|
||||
Delete(cpt);
|
||||
} else {
|
||||
// TODO: report line number of where the feature comes from
|
||||
Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, class_name);
|
||||
}
|
||||
}
|
||||
// Replace storing a pointer to underlying class with a smart pointer (intended for use with non-intrusive smart pointers)
|
||||
SwigType *smart = Swig_cparse_smartptr(n);
|
||||
String *wrap_class = NewStringf("&_wrap_class_%s", class_name);
|
||||
if(smart){
|
||||
if (smart) {
|
||||
SwigType_add_pointer(smart);
|
||||
SwigType_remember_clientdata(smart, wrap_class);
|
||||
}
|
||||
Delete(smart);
|
||||
Delete(smartptr);
|
||||
//String *wrap_class = NewStringf("&_wrap_class_%s", class_name);
|
||||
SwigType_remember_clientdata(t, wrap_class);
|
||||
|
||||
|
|
@ -1064,6 +1052,7 @@ public:
|
|||
|
||||
Delete(base_class);
|
||||
Delete(base_class_names);
|
||||
Delete(smart);
|
||||
Delete(t);
|
||||
Delete(s_members_tab);
|
||||
s_members_tab = 0;
|
||||
|
|
|
|||
|
|
@ -4161,15 +4161,11 @@ public:
|
|||
Printf(clientdata, "&%s_clientdata", templ);
|
||||
SwigType_remember_mangleddata(pmname, clientdata);
|
||||
|
||||
String *smartptr = Getattr(n, "feature:smartptr");
|
||||
if (smartptr) {
|
||||
SwigType *spt = Swig_cparse_type(smartptr);
|
||||
SwigType *smart = SwigType_typedef_resolve_all(spt);
|
||||
SwigType *smart = Swig_cparse_smartptr(n);
|
||||
if (smart) {
|
||||
SwigType_add_pointer(smart);
|
||||
String *smart_pmname = SwigType_manglestr(smart);
|
||||
SwigType_remember_mangleddata(smart_pmname, clientdata);
|
||||
Delete(spt);
|
||||
Delete(smart);
|
||||
Delete(smart_pmname);
|
||||
}
|
||||
|
||||
|
|
@ -4195,6 +4191,7 @@ public:
|
|||
Printv(f_init, " d = md;\n", NIL);
|
||||
|
||||
Delete(clientdata);
|
||||
Delete(smart);
|
||||
Delete(rname);
|
||||
Delete(pname);
|
||||
Delete(mname);
|
||||
|
|
@ -4392,18 +4389,8 @@ public:
|
|||
/* Complete the class */
|
||||
if (shadow) {
|
||||
/* Generate a class registration function */
|
||||
String *smartptr = Getattr(n, "feature:smartptr"); // Replace storing a pointer to underlying class with a smart pointer (intended for use with non-intrusive smart pointers)
|
||||
SwigType *smart = 0;
|
||||
if (smartptr) {
|
||||
SwigType *cpt = Swig_cparse_type(smartptr);
|
||||
if (cpt) {
|
||||
smart = SwigType_typedef_resolve_all(cpt);
|
||||
Delete(cpt);
|
||||
} else {
|
||||
// TODO: report line number of where the feature comes from
|
||||
Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, real_classname);
|
||||
}
|
||||
}
|
||||
// Replace storing a pointer to underlying class with a smart pointer (intended for use with non-intrusive smart pointers)
|
||||
SwigType *smart = Swig_cparse_smartptr(n);
|
||||
SwigType *ct = Copy(smart ? smart : real_classname);
|
||||
SwigType_add_pointer(ct);
|
||||
SwigType *realct = Copy(real_classname);
|
||||
|
|
|
|||
|
|
@ -1830,10 +1830,19 @@ public:
|
|||
Wrapper_add_local(f, "classname", classname);
|
||||
}
|
||||
if (action) {
|
||||
Printf(action, "\nDATA_PTR(self) = %s;", Swig_cresult_name());
|
||||
if (GetFlag(pn, "feature:trackobjects")) {
|
||||
Printf(action, "\nSWIG_RubyAddTracking(%s, self);", Swig_cresult_name());
|
||||
SwigType *smart = Swig_cparse_smartptr(pn);
|
||||
String *result_name = NewStringf("%s%s", smart ? "smart" : "", Swig_cresult_name());
|
||||
if (smart) {
|
||||
String *result_var = NewStringf("%s *%s = 0", SwigType_namestr(smart), result_name);
|
||||
Wrapper_add_local(f, result_name, result_var);
|
||||
Printf(action, "\n%s = new %s(%s);", result_name, SwigType_namestr(smart), Swig_cresult_name());
|
||||
}
|
||||
Printf(action, "\nDATA_PTR(self) = %s;", result_name);
|
||||
if (GetFlag(pn, "feature:trackobjects")) {
|
||||
Printf(action, "\nSWIG_RubyAddTracking(%s, self);", result_name);
|
||||
}
|
||||
Delete(result_name);
|
||||
Delete(smart);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1921,11 +1930,17 @@ public:
|
|||
|
||||
/* Extra code needed for new and initialize methods */
|
||||
if (current == CONSTRUCTOR_ALLOCATE) {
|
||||
Node *pn = Swig_methodclass(n);
|
||||
SwigType *smart = Swig_cparse_smartptr(pn);
|
||||
if (smart)
|
||||
SwigType_add_pointer(smart);
|
||||
String *classtype = smart ? smart : t;
|
||||
need_result = 1;
|
||||
Printf(f->code, "VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE%s);\n", Char(SwigType_manglestr(t)));
|
||||
Printf(f->code, "VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE%s);\n", Char(SwigType_manglestr(classtype)));
|
||||
Printf(f->code, "#ifndef HAVE_RB_DEFINE_ALLOC_FUNC\n");
|
||||
Printf(f->code, "rb_obj_call_init(vresult, argc, argv);\n");
|
||||
Printf(f->code, "#endif\n");
|
||||
Delete(smart);
|
||||
} else if (current == CONSTRUCTOR_INITIALIZE) {
|
||||
need_result = 1;
|
||||
}
|
||||
|
|
@ -2431,11 +2446,17 @@ public:
|
|||
Printv(klass->init, "rb_include_module(", klass->mImpl, ", ", bmangle, ");\n", NIL);
|
||||
Delete(bmangle);
|
||||
} else {
|
||||
String *bmangle = SwigType_manglestr(btype);
|
||||
SwigType *smart = Swig_cparse_smartptr(base.item);
|
||||
if (smart) {
|
||||
SwigType_add_pointer(smart);
|
||||
SwigType_remember(smart);
|
||||
}
|
||||
String *bmangle = SwigType_manglestr(smart ? smart : btype);
|
||||
Insert(bmangle, 0, "((swig_class *) SWIGTYPE");
|
||||
Append(bmangle, "->clientdata)->klass");
|
||||
Replaceall(klass->init, "$super", bmangle);
|
||||
Delete(bmangle);
|
||||
Delete(smart);
|
||||
}
|
||||
Delete(btype);
|
||||
}
|
||||
|
|
@ -2537,9 +2558,15 @@ public:
|
|||
SwigType *tt = NewString(name);
|
||||
SwigType_add_pointer(tt);
|
||||
SwigType_remember(tt);
|
||||
String *tm = SwigType_manglestr(tt);
|
||||
SwigType *smart = Swig_cparse_smartptr(n);
|
||||
if (smart) {
|
||||
SwigType_add_pointer(smart);
|
||||
SwigType_remember(smart);
|
||||
}
|
||||
String *tm = SwigType_manglestr(smart ? smart : tt);
|
||||
Printf(klass->init, "SWIG_TypeClientData(SWIGTYPE%s, (void *) &SwigClass%s);\n", tm, valid_name);
|
||||
Delete(tm);
|
||||
Delete(smart);
|
||||
Delete(tt);
|
||||
Delete(valid_name);
|
||||
|
||||
|
|
@ -2718,7 +2745,9 @@ public:
|
|||
String *pname0 = Swig_cparm_name(0, 0);
|
||||
|
||||
Printv(freefunc, "free_", klass->mname, NIL);
|
||||
Printv(freebody, "SWIGINTERN void\n", freefunc, "(", klass->type, " *", pname0, ") {\n", tab4, NIL);
|
||||
Printv(freebody, "SWIGINTERN void\n", freefunc, "(void *self) {\n", NIL);
|
||||
Printv(freebody, tab4, klass->type, " *", pname0, " = (", klass->type, " *)self;\n", NIL);
|
||||
Printv(freebody, tab4, NIL);
|
||||
|
||||
/* Check to see if object tracking is activated for the class
|
||||
that owns this destructor. */
|
||||
|
|
|
|||
|
|
@ -256,11 +256,8 @@ class TypePass:private Dispatcher {
|
|||
SwigType_inherit(clsname, bname, cast, 0);
|
||||
String *smartptr = Getattr(first, "feature:smartptr");
|
||||
if (smartptr) {
|
||||
SwigType *smart = 0;
|
||||
SwigType *spt = Swig_cparse_type(smartptr);
|
||||
if (spt) {
|
||||
smart = SwigType_typedef_resolve_all(spt);
|
||||
Delete(spt);
|
||||
SwigType *smart = Swig_cparse_smartptr(first);
|
||||
if (smart) {
|
||||
/* Record a (fake) inheritance relationship between smart pointer
|
||||
and smart pointer to base class, so that smart pointer upcasts
|
||||
are automatically generated. */
|
||||
|
|
@ -282,10 +279,8 @@ class TypePass:private Dispatcher {
|
|||
Swig_warning(WARN_LANG_SMARTPTR_MISSING, Getfile(first), Getline(first), "Base class '%s' of '%s' is not similarly marked as a smart pointer.\n", SwigType_namestr(Getattr(bclass, "name")), SwigType_namestr(Getattr(first, "name")));
|
||||
Delete(convcode);
|
||||
Delete(bsmart);
|
||||
Delete(smart);
|
||||
} else {
|
||||
Swig_error(Getfile(first), Getline(first), "Invalid type (%s) in 'smartptr' feature for class %s.\n", SwigType_namestr(smartptr), SwigType_namestr(clsname));
|
||||
}
|
||||
Delete(smart);
|
||||
} else {
|
||||
if (GetFlag(bclass, "feature:smartptr"))
|
||||
Swig_warning(WARN_LANG_SMARTPTR_MISSING, Getfile(first), Getline(first), "Derived class '%s' of '%s' is not similarly marked as a smart pointer.\n", SwigType_namestr(Getattr(first, "name")), SwigType_namestr(Getattr(bclass, "name")));
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue