From b8d383cb4a5edd9dd4feb4fa528fefca2a2a3c1f Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Sat, 25 Feb 2017 15:44:49 +0900 Subject: [PATCH 01/16] [ruby] add simple assertions. --- Examples/test-suite/ruby/swig_assert.rb | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/Examples/test-suite/ruby/swig_assert.rb b/Examples/test-suite/ruby/swig_assert.rb index 69a1a0207..2d5d1f406 100644 --- a/Examples/test-suite/ruby/swig_assert.rb +++ b/Examples/test-suite/ruby/swig_assert.rb @@ -15,6 +15,21 @@ class SwigRubyError < RuntimeError end +# +# simple assertions. strings are not needed as arguments. +# +def simple_assert_equal(a, b) + unless a == b + raise SwigRubyError.new("\n#{a} expected but was \n#{b}") + end +end + +def simple_assert(a) + unless a + raise SwigRubyError.new("assertion falied.") + end +end + # # Asserts whether a and b are equal. # From 50e495c453a3d5beb8f3f1fcf2d3e0ba0e883575 Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Wed, 1 Mar 2017 16:08:45 +0900 Subject: [PATCH 02/16] [ruby] use template specialization for swig::asptr,asval functions on std:shared_ptr. --- Lib/ruby/rubystdcommon.swg | 75 +++++++++++++++++++++++++++++++++++++- 1 file changed, 74 insertions(+), 1 deletion(-) diff --git a/Lib/ruby/rubystdcommon.swg b/Lib/ruby/rubystdcommon.swg index f72745b56..9a72ef489 100644 --- a/Lib/ruby/rubystdcommon.swg +++ b/Lib/ruby/rubystdcommon.swg @@ -198,6 +198,79 @@ namespace swig { inline bool check(VALUE obj) { return traits_check::category>::check(obj); } -} + + template + struct traits_asptr > { + static int asptr(VALUE obj, std::shared_ptr **val) { + std::shared_ptr *p=0; + swig_type_info *descriptor = type_info >(); + swig_ruby_owntype newmem = {0, 0}; + int res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR; + if (SWIG_IsOK(res) && p) { + if (val && *val) **val = *p; + if (newmem.own & SWIG_CAST_NEW_MEMORY) delete p; + return SWIG_OK; + } else { + return SWIG_ERROR; + } + } + }; + + template + struct traits_asval > { + static int asval(VALUE obj, std::shared_ptr *val) { + if (val) { + std::shared_ptr ret; + std::shared_ptr *p=&ret; + int res = traits_asptr >::asptr(obj, &p); + if (!SWIG_IsOK(res)) return res; + if (val) *val = ret; + return SWIG_OK; + } else { + return traits_asptr >::asptr(obj, (std::shared_ptr **)(0)); + } + } + }; + + template + struct traits_asval*> { + static int asval(VALUE obj, std::shared_ptr **val) { + if (val && *val) { + typedef typename noconst_traits >::noconst_type noconst_type; + noconst_type ret; + noconst_type *p = &ret; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) { + **(const_cast(val)) = ret; + } + return res; + } else { + return traits_asptr >::asptr(obj, (std::shared_ptr **)(0)); + } + } + }; + + template + struct traits_as, pointer_category> { + static std::shared_ptr as(VALUE obj, bool throw_error) { + std::shared_ptr ret; + std::shared_ptr *v = &ret; + int res = (obj ? traits_asptr >::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res)) { + return ret; + } else { + // Uninitialized return value, no Type() constructor required. + if (throw_error) throw std::invalid_argument("bad type"); + VALUE lastErr = rb_gv_get("$!"); + if (lastErr == Qnil) { + SWIG_Error(SWIG_TypeError, swig::type_name >()); + } + static std::shared_ptr *v_def = (std::shared_ptr*) malloc(sizeof(std::shared_ptr)); + memset(v_def,0,sizeof(std::shared_ptr)); + return *v_def; + } + } + }; } +} From a84ea749b3ae630212fc2928be6697e34b22faed Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Wed, 1 Mar 2017 21:32:03 +0900 Subject: [PATCH 03/16] [ruby] add tests for upcasting std::shared_ptr within std containers. --- Examples/test-suite/cpp11_shared_ptr_upcast.i | 97 +++++++++++++++++++ Examples/test-suite/ruby/Makefile.in | 1 + .../ruby/cpp11_shared_ptr_upcast_runme.rb | 12 +++ 3 files changed, 110 insertions(+) create mode 100644 Examples/test-suite/cpp11_shared_ptr_upcast.i create mode 100644 Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb diff --git a/Examples/test-suite/cpp11_shared_ptr_upcast.i b/Examples/test-suite/cpp11_shared_ptr_upcast.i new file mode 100644 index 000000000..637563d53 --- /dev/null +++ b/Examples/test-suite/cpp11_shared_ptr_upcast.i @@ -0,0 +1,97 @@ +%module cpp11_shared_ptr_upcast + +%{ +#include +#include +#include +#include +#include +#include +%} + +%include std_vector.i +%include std_map.i +%include std_shared_ptr.i + +%{ + +class Base { +public: + Base() : m(-1) {} + Base(int i) : m(i) {} + int get_m() { return m; } + int m; +}; + +class Derived : public Base { +public: + Derived() : n(-2) {} + Derived(int i) : n(i) {} + int get_n() { return n; } + int n; +}; + + typedef std::shared_ptr BasePtr; + typedef std::shared_ptr DerivedPtr; + + int derived_num(DerivedPtr v) { + return (*v).get_n(); + } + + int derived_num(std::vector v) { + return (*v[0]).get_n(); + } + + int derived_num(std::map v) { + return (*v[0]).get_n(); + } + + int base_num(BasePtr v) { + return (*v).get_m(); + } + + int base_num(std::vector v) { + return (*v[0]).get_m(); + } + + int base_num(std::map v) { + return (*v[0]).get_m(); + } + +%} + + +%shared_ptr(Base); +%shared_ptr(Derived); + +%template(BaseList) std::vector >; +%template(DerivedList) std::vector >; + +%template(BaseMap) std::map >; +%template(DerivedMap) std::map >; + +class Base { +public: + Base(); + int get_m(); + int m; +}; + +class Derived : public Base { +public: + Derived(); + Derived(int i); + int get_n(); + int n; +}; + +typedef std::shared_ptr BasePtr; +typedef std::shared_ptr DerivedPtr; + +int derived_num(DerivedPtr); +int derived_num(std::vector > v); +int derived_num(std::map v); +int base_num(BasePtr); +int base_num(std::vector > v); +int base_num(std::map v); + diff --git a/Examples/test-suite/ruby/Makefile.in b/Examples/test-suite/ruby/Makefile.in index a127860b0..a560aa0f9 100644 --- a/Examples/test-suite/ruby/Makefile.in +++ b/Examples/test-suite/ruby/Makefile.in @@ -31,6 +31,7 @@ CPP_TEST_CASES = \ CPP11_TEST_CASES = \ cpp11_hash_tables \ + cpp11_shared_ptr_upcast C_TEST_CASES += \ li_cstring \ diff --git a/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb b/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb new file mode 100644 index 000000000..188f9ccbf --- /dev/null +++ b/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb @@ -0,0 +1,12 @@ +require 'swig_assert' +require 'cpp11_shared_ptr_upcast' + + +include Cpp11_shared_ptr_upcast + +simple_assert_equal( 7, derived_num(Derived.new(7)) ) +simple_assert_equal( 7, derived_num([Derived.new(7)]) ) +simple_assert_equal( 7, derived_num({0 => Derived.new(7)}) ) +simple_assert_equal(-1, base_num(Derived.new(7)) ) +simple_assert_equal(-1, base_num([Derived.new(7)]) ) +simple_assert_equal(-1, base_num({0 => Derived.new(7)}) ) From a784ace983b49346d973553987e3574cba0eeeaa Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Thu, 2 Mar 2017 09:47:46 +0900 Subject: [PATCH 04/16] [ruby] move template specialization to std_shared_ptr.i. --- Lib/ruby/rubystdcommon.swg | 77 ++-------------------------------- Lib/ruby/std_shared_ptr.i | 85 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 88 insertions(+), 74 deletions(-) diff --git a/Lib/ruby/rubystdcommon.swg b/Lib/ruby/rubystdcommon.swg index 9a72ef489..2f7c03c0b 100644 --- a/Lib/ruby/rubystdcommon.swg +++ b/Lib/ruby/rubystdcommon.swg @@ -7,6 +7,8 @@ %fragment("StdTraits","header",fragment="StdTraitsCommon") { +%#define SWIG_RUBYSTDCOMMON + namespace swig { /* Traits that provides the from method @@ -198,79 +200,6 @@ namespace swig { inline bool check(VALUE obj) { return traits_check::category>::check(obj); } - - template - struct traits_asptr > { - static int asptr(VALUE obj, std::shared_ptr **val) { - std::shared_ptr *p=0; - swig_type_info *descriptor = type_info >(); - swig_ruby_owntype newmem = {0, 0}; - int res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR; - if (SWIG_IsOK(res) && p) { - if (val && *val) **val = *p; - if (newmem.own & SWIG_CAST_NEW_MEMORY) delete p; - return SWIG_OK; - } else { - return SWIG_ERROR; - } - } - }; - - template - struct traits_asval > { - static int asval(VALUE obj, std::shared_ptr *val) { - if (val) { - std::shared_ptr ret; - std::shared_ptr *p=&ret; - int res = traits_asptr >::asptr(obj, &p); - if (!SWIG_IsOK(res)) return res; - if (val) *val = ret; - return SWIG_OK; - } else { - return traits_asptr >::asptr(obj, (std::shared_ptr **)(0)); - } - } - }; - - template - struct traits_asval*> { - static int asval(VALUE obj, std::shared_ptr **val) { - if (val && *val) { - typedef typename noconst_traits >::noconst_type noconst_type; - noconst_type ret; - noconst_type *p = &ret; - int res = traits_asptr::asptr(obj, &p); - if (SWIG_IsOK(res)) { - **(const_cast(val)) = ret; - } - return res; - } else { - return traits_asptr >::asptr(obj, (std::shared_ptr **)(0)); - } - } - }; - - template - struct traits_as, pointer_category> { - static std::shared_ptr as(VALUE obj, bool throw_error) { - std::shared_ptr ret; - std::shared_ptr *v = &ret; - int res = (obj ? traits_asptr >::asptr(obj, &v) : SWIG_ERROR); - if (SWIG_IsOK(res)) { - return ret; - } else { - // Uninitialized return value, no Type() constructor required. - if (throw_error) throw std::invalid_argument("bad type"); - VALUE lastErr = rb_gv_get("$!"); - if (lastErr == Qnil) { - SWIG_Error(SWIG_TypeError, swig::type_name >()); - } - static std::shared_ptr *v_def = (std::shared_ptr*) malloc(sizeof(std::shared_ptr)); - memset(v_def,0,sizeof(std::shared_ptr)); - return *v_def; - } - } - }; +} } -} diff --git a/Lib/ruby/std_shared_ptr.i b/Lib/ruby/std_shared_ptr.i index df873679c..4192c87cb 100644 --- a/Lib/ruby/std_shared_ptr.i +++ b/Lib/ruby/std_shared_ptr.i @@ -1,2 +1,87 @@ #define SWIG_SHARED_PTR_NAMESPACE std %include + + + /* + * We want to put the folloing code after the fragment "StdTraits" at rubystdcommon.swg. + * This code is needed if and only if "StdTraits" and this std_shared_ptr.i are included at the same time. + * They don't always require each other. So specifying the dependecy by using %fragment does not work. + */ +%wrapper %{ +#ifdef SWIG_RUBYSTDCOMMON +namespace swig { + template + struct traits_asptr > { + static int asptr(VALUE obj, std::shared_ptr **val) { + std::shared_ptr *p=0; + swig_type_info *descriptor = type_info >(); + swig_ruby_owntype newmem = {0, 0}; + int res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR; + if (SWIG_IsOK(res) && p) { + if (val && *val) **val = *p; + if (newmem.own & SWIG_CAST_NEW_MEMORY) delete p; + return SWIG_OK; + } else { + return SWIG_ERROR; + } + } + }; + + template + struct traits_asval > { + static int asval(VALUE obj, std::shared_ptr *val) { + if (val) { + std::shared_ptr ret; + std::shared_ptr *p=&ret; + int res = traits_asptr >::asptr(obj, &p); + if (!SWIG_IsOK(res)) return res; + if (val) *val = ret; + return SWIG_OK; + } else { + return traits_asptr >::asptr(obj, (std::shared_ptr **)(0)); + } + } + }; + + template + struct traits_asval*> { + static int asval(VALUE obj, std::shared_ptr **val) { + if (val && *val) { + typedef typename noconst_traits >::noconst_type noconst_type; + noconst_type ret; + noconst_type *p = &ret; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) { + **(const_cast(val)) = ret; + } + return res; + } else { + return traits_asptr >::asptr(obj, (std::shared_ptr **)(0)); + } + } + }; + + template + struct traits_as, pointer_category> { + static std::shared_ptr as(VALUE obj, bool throw_error) { + std::shared_ptr ret; + std::shared_ptr *v = &ret; + int res = (obj ? traits_asptr >::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res)) { + return ret; + } else { + // Uninitialized return value, no Type() constructor required. + if (throw_error) throw std::invalid_argument("bad type"); + VALUE lastErr = rb_gv_get("$!"); + if (lastErr == Qnil) { + SWIG_Error(SWIG_TypeError, swig::type_name >()); + } + static std::shared_ptr *v_def = (std::shared_ptr*) malloc(sizeof(std::shared_ptr)); + memset(v_def,0,sizeof(std::shared_ptr)); + return *v_def; + } + } + }; + } +#endif +%} From 806f49bf5809a73ffb5478cbac0a247a0c679dd2 Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Thu, 2 Mar 2017 11:55:09 +0900 Subject: [PATCH 05/16] [ruby] edit comments [skip ci] --- Lib/ruby/std_shared_ptr.i | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/Lib/ruby/std_shared_ptr.i b/Lib/ruby/std_shared_ptr.i index 4192c87cb..02a225b6e 100644 --- a/Lib/ruby/std_shared_ptr.i +++ b/Lib/ruby/std_shared_ptr.i @@ -3,9 +3,10 @@ /* - * We want to put the folloing code after the fragment "StdTraits" at rubystdcommon.swg. - * This code is needed if and only if "StdTraits" and this std_shared_ptr.i are included at the same time. - * They don't always require each other. So specifying the dependecy by using %fragment does not work. + * We want to put the following code after the fragment "StdTraits" at rubystdcommon.swg. + * This code is needed if and only if the fragment and this std_shared_ptr.i are included at the same time. + * They don't always require each other. The order of including them is not predetermined either. + * So specifying the dependecy by using %fragment does not work. */ %wrapper %{ #ifdef SWIG_RUBYSTDCOMMON From f96c2ad73d2e4d6ec81941fd5f4b405c7f8828f3 Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Fri, 3 Mar 2017 12:50:23 +0900 Subject: [PATCH 06/16] [ruby] For swig::from, use template specialization to convert shared_ptr to shared_ptr. --- Examples/test-suite/cpp11_shared_ptr_const.i | 47 +++++++++++++++++++ Examples/test-suite/ruby/Makefile.in | 1 + .../ruby/cpp11_shared_ptr_const_runme.rb | 7 +++ Lib/ruby/rubystdcommon.swg | 2 + Lib/ruby/std_shared_ptr.i | 15 ++++++ 5 files changed, 72 insertions(+) create mode 100644 Examples/test-suite/cpp11_shared_ptr_const.i create mode 100644 Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb diff --git a/Examples/test-suite/cpp11_shared_ptr_const.i b/Examples/test-suite/cpp11_shared_ptr_const.i new file mode 100644 index 000000000..ef6e7ad2c --- /dev/null +++ b/Examples/test-suite/cpp11_shared_ptr_const.i @@ -0,0 +1,47 @@ +%module cpp11_shared_ptr_const + +%{ + +#include +#include + +class Foo +{ +public: + Foo(int i) : m(i) {} + int get_m() { return m;} + int m; +}; + +std::vector > foo_vec() { + std::vector > result; + result.push_back( std::shared_ptr(new Foo(7)) ); + return result; +} + +std::vector > const_foo_vec() { + std::vector > result; + result.push_back( std::shared_ptr(new Foo(7)) ); + return result; +} + +%} + +%include +%include + +%shared_ptr(Foo); + +%template (FooVector) std::vector >; +%template (FooConstVector) std::vector >; + +std::vector > foo_vec() const; +std::vector > const_foo_vec() const; + +class Foo +{ +public: + Foo(int i); + int get_m(); + int m; +}; diff --git a/Examples/test-suite/ruby/Makefile.in b/Examples/test-suite/ruby/Makefile.in index a127860b0..0fde9a2ff 100644 --- a/Examples/test-suite/ruby/Makefile.in +++ b/Examples/test-suite/ruby/Makefile.in @@ -31,6 +31,7 @@ CPP_TEST_CASES = \ CPP11_TEST_CASES = \ cpp11_hash_tables \ + cpp11_shared_ptr_const C_TEST_CASES += \ li_cstring \ diff --git a/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb b/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb new file mode 100644 index 000000000..a881ed056 --- /dev/null +++ b/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb @@ -0,0 +1,7 @@ +require "swig_assert" +require "cpp11_shared_ptr_const" + +include Cpp11_shared_ptr_const + +simple_assert_equal(7, foo_vec()[0].get_m ) +simple_assert_equal(7, const_foo_vec()[0].get_m ) diff --git a/Lib/ruby/rubystdcommon.swg b/Lib/ruby/rubystdcommon.swg index f72745b56..2f7c03c0b 100644 --- a/Lib/ruby/rubystdcommon.swg +++ b/Lib/ruby/rubystdcommon.swg @@ -7,6 +7,8 @@ %fragment("StdTraits","header",fragment="StdTraitsCommon") { +%#define SWIG_RUBYSTDCOMMON + namespace swig { /* Traits that provides the from method diff --git a/Lib/ruby/std_shared_ptr.i b/Lib/ruby/std_shared_ptr.i index df873679c..1d4235ab8 100644 --- a/Lib/ruby/std_shared_ptr.i +++ b/Lib/ruby/std_shared_ptr.i @@ -1,2 +1,17 @@ #define SWIG_SHARED_PTR_NAMESPACE std %include + + +%wrapper %{ +#ifdef SWIG_RUBYSTDCOMMON +namespace swig { + template + struct traits_from > { + static VALUE from(const std::shared_ptr& val) { + std::shared_ptr p = std::const_pointer_cast(val); + return swig::from(p); + } + }; +}; +#endif +%} From b91e03d39ab3d45915d5cb8ddf4b9431ab264aa6 Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Fri, 3 Mar 2017 16:58:51 +0900 Subject: [PATCH 07/16] [ruby] add tests for shared_ptr of const Type. --- Examples/test-suite/cpp11_shared_ptr_const.i | 22 ++++++++++++++----- .../ruby/cpp11_shared_ptr_const_runme.rb | 6 +++-- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/Examples/test-suite/cpp11_shared_ptr_const.i b/Examples/test-suite/cpp11_shared_ptr_const.i index ef6e7ad2c..1989e3261 100644 --- a/Examples/test-suite/cpp11_shared_ptr_const.i +++ b/Examples/test-suite/cpp11_shared_ptr_const.i @@ -13,15 +13,23 @@ public: int m; }; -std::vector > foo_vec() { +std::shared_ptr foo(Foo v) { + return std::shared_ptr(new Foo(v)); +} + +std::shared_ptr const_foo(Foo v) { + return std::shared_ptr(new Foo(v)); +} + +std::vector > foo_vec(Foo v) { std::vector > result; - result.push_back( std::shared_ptr(new Foo(7)) ); + result.push_back( std::shared_ptr(new Foo(v)) ); return result; } -std::vector > const_foo_vec() { +std::vector > const_foo_vec(Foo v) { std::vector > result; - result.push_back( std::shared_ptr(new Foo(7)) ); + result.push_back( std::shared_ptr(new Foo(v)) ); return result; } @@ -35,8 +43,10 @@ std::vector > const_foo_vec() { %template (FooVector) std::vector >; %template (FooConstVector) std::vector >; -std::vector > foo_vec() const; -std::vector > const_foo_vec() const; +std::shared_ptr foo(Foo v); +std::shared_ptr const_foo(Foo v); +std::vector > foo_vec(Foo v) const; +std::vector > const_foo_vec(Foo v) const; class Foo { diff --git a/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb b/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb index a881ed056..db56252da 100644 --- a/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb +++ b/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb @@ -3,5 +3,7 @@ require "cpp11_shared_ptr_const" include Cpp11_shared_ptr_const -simple_assert_equal(7, foo_vec()[0].get_m ) -simple_assert_equal(7, const_foo_vec()[0].get_m ) +simple_assert_equal(1, foo( Foo.new(1) ).get_m ) +simple_assert_equal(7, const_foo( Foo.new(7) ).get_m ) +simple_assert_equal(7, foo_vec( Foo.new(7) )[0].get_m ) +simple_assert_equal(8, const_foo_vec( Foo.new(8) )[0].get_m ) From cb1f89cb6860afd30f2f2bff8e5f03feedb8644d Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Tue, 7 Mar 2017 11:43:01 +0900 Subject: [PATCH 08/16] [ruby] must not do a null check for VALUE. --- Lib/ruby/std_shared_ptr.i | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Lib/ruby/std_shared_ptr.i b/Lib/ruby/std_shared_ptr.i index 02a225b6e..d3f67bab4 100644 --- a/Lib/ruby/std_shared_ptr.i +++ b/Lib/ruby/std_shared_ptr.i @@ -67,9 +67,9 @@ namespace swig { static std::shared_ptr as(VALUE obj, bool throw_error) { std::shared_ptr ret; std::shared_ptr *v = &ret; - int res = (obj ? traits_asptr >::asptr(obj, &v) : SWIG_ERROR); + int res = traits_asptr >::asptr(obj, &v); if (SWIG_IsOK(res)) { - return ret; + return ret; } else { // Uninitialized return value, no Type() constructor required. if (throw_error) throw std::invalid_argument("bad type"); @@ -82,7 +82,7 @@ namespace swig { return *v_def; } } - }; + }; } #endif %} From b32854bc592c82d1401ed749f6ca7fff686180ef Mon Sep 17 00:00:00 2001 From: Takashi Tamura Date: Wed, 29 Mar 2017 19:11:44 +0900 Subject: [PATCH 09/16] use forward declaration to treat the dependency of fragments --- Examples/test-suite/cpp11_shared_ptr_upcast.i | 6 ++--- Lib/ruby/rubystdcommon.swg | 5 ++-- Lib/ruby/rubystdcommon_forward.swg | 14 ++++++++++ Lib/ruby/std_shared_ptr.i | 26 ++++++++++++------- 4 files changed, 35 insertions(+), 16 deletions(-) create mode 100644 Lib/ruby/rubystdcommon_forward.swg diff --git a/Examples/test-suite/cpp11_shared_ptr_upcast.i b/Examples/test-suite/cpp11_shared_ptr_upcast.i index 637563d53..22bc55594 100644 --- a/Examples/test-suite/cpp11_shared_ptr_upcast.i +++ b/Examples/test-suite/cpp11_shared_ptr_upcast.i @@ -9,9 +9,9 @@ #include %} -%include std_vector.i -%include std_map.i -%include std_shared_ptr.i +%include +%include +%include %{ diff --git a/Lib/ruby/rubystdcommon.swg b/Lib/ruby/rubystdcommon.swg index 2f7c03c0b..d1d366cf0 100644 --- a/Lib/ruby/rubystdcommon.swg +++ b/Lib/ruby/rubystdcommon.swg @@ -3,12 +3,11 @@ * The Ruby classes, for C++ * ------------------------------------------------------------ */ %include +%include -%fragment("StdTraits","header",fragment="StdTraitsCommon") +%fragment("StdTraits","header",fragment="StdTraitsCommon",fragment="StdTraitsForwardDeclaration") { -%#define SWIG_RUBYSTDCOMMON - namespace swig { /* Traits that provides the from method diff --git a/Lib/ruby/rubystdcommon_forward.swg b/Lib/ruby/rubystdcommon_forward.swg new file mode 100644 index 000000000..27bcb9960 --- /dev/null +++ b/Lib/ruby/rubystdcommon_forward.swg @@ -0,0 +1,14 @@ +%fragment("StdTraitsForwardDeclaration","header") +{ +namespace swig { + template struct traits_asptr; + template struct traits_asval; + struct pointer_category; + template struct traits_as; + template struct traits_from; + template struct noconst_traits; + template swig_type_info* type_info(); + template const char* type_name(); + template VALUE from(const Type& val); +} +} diff --git a/Lib/ruby/std_shared_ptr.i b/Lib/ruby/std_shared_ptr.i index 0610d590d..5d56b8750 100644 --- a/Lib/ruby/std_shared_ptr.i +++ b/Lib/ruby/std_shared_ptr.i @@ -1,16 +1,15 @@ #define SWIG_SHARED_PTR_NAMESPACE std %include +%include - /* - * We want to put the following code after the fragment "StdTraits" at rubystdcommon.swg. - * This code is needed if and only if the fragment and this std_shared_ptr.i are included at the same time. - * They don't always require each other. The order of including them is not predetermined either. - * So specifying the dependecy by using %fragment does not work. - */ -%wrapper %{ -#ifdef SWIG_RUBYSTDCOMMON +%fragment("StdSharedPtrTraits","header",fragment="StdTraitsForwardDeclaration") +{ namespace swig { + /* + template specialization for functions defined in rubystdcommon.swg. + here we should treat smart pointers in a way different from the way we treat raw pointers. + */ template struct traits_asptr > { static int asptr(VALUE obj, std::shared_ptr **val) { @@ -84,6 +83,11 @@ namespace swig { } }; + /* + we have to remove the const qualifier to work around a BUG + SWIG_TypeQuery("std::shared_ptr") == NULL, + which is caused by %template treating const qualifiers not properly. + */ template struct traits_from > { static VALUE from(const std::shared_ptr& val) { @@ -92,5 +96,7 @@ namespace swig { } }; } -#endif -%} +} + +//force the fragment. +%fragment("StdSharedPtrTraits"); From d56c8ef9ffcf96acbe7e9cc69eefd11e81488ada Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Fri, 31 Mar 2017 07:32:04 +0100 Subject: [PATCH 10/16] Rename new Ruby assert functions used in test-suite --- Examples/test-suite/ruby/swig_assert.rb | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/Examples/test-suite/ruby/swig_assert.rb b/Examples/test-suite/ruby/swig_assert.rb index 2d5d1f406..5b3f9b5ce 100644 --- a/Examples/test-suite/ruby/swig_assert.rb +++ b/Examples/test-suite/ruby/swig_assert.rb @@ -1,12 +1,7 @@ #!/usr/bin/env ruby # -# A simple function to create useful asserts +# Useful assert functions # -# -# -# -# - # # Exception raised when some swig binding test fails @@ -16,15 +11,15 @@ end # -# simple assertions. strings are not needed as arguments. +# Simple assertions. Strings are not needed as arguments. # -def simple_assert_equal(a, b) +def swig_assert_equal_simple(a, b) unless a == b raise SwigRubyError.new("\n#{a} expected but was \n#{b}") end end -def simple_assert(a) +def swig_assert_simple(a) unless a raise SwigRubyError.new("assertion falied.") end From bd233408e8ec192b342dc02e014906affab9e08f Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Fri, 7 Apr 2017 07:34:58 +0100 Subject: [PATCH 11/16] Add shared_ptr non-overloaded upcast tests --- Examples/test-suite/cpp11_shared_ptr_upcast.i | 75 +++++++++++++------ .../ruby/cpp11_shared_ptr_upcast_runme.rb | 11 +++ 2 files changed, 65 insertions(+), 21 deletions(-) diff --git a/Examples/test-suite/cpp11_shared_ptr_upcast.i b/Examples/test-suite/cpp11_shared_ptr_upcast.i index 22bc55594..9f65eb7e1 100644 --- a/Examples/test-suite/cpp11_shared_ptr_upcast.i +++ b/Examples/test-suite/cpp11_shared_ptr_upcast.i @@ -31,33 +31,58 @@ public: int n; }; - typedef std::shared_ptr BasePtr; - typedef std::shared_ptr DerivedPtr; +typedef std::shared_ptr BasePtr; +typedef std::shared_ptr DerivedPtr; - int derived_num(DerivedPtr v) { - return (*v).get_n(); - } +// non-overloaded +int derived_num1(DerivedPtr v) { + return (*v).get_n(); +} - int derived_num(std::vector v) { - return (*v[0]).get_n(); - } +int derived_num2(std::vector v) { + return (*v[0]).get_n(); +} - int derived_num(std::map v) { - return (*v[0]).get_n(); - } +int derived_num3(std::map v) { + return (*v[0]).get_n(); +} - int base_num(BasePtr v) { - return (*v).get_m(); - } +int base_num1(BasePtr v) { + return (*v).get_m(); +} - int base_num(std::vector v) { - return (*v[0]).get_m(); - } +int base_num2(std::vector v) { + return (*v[0]).get_m(); +} - int base_num(std::map v) { - return (*v[0]).get_m(); - } +int base_num3(std::map v) { + return (*v[0]).get_m(); +} +// overloaded +int derived_num(DerivedPtr v) { + return derived_num1(v); +} + +int derived_num(std::vector v) { + return derived_num2(v); +} + +int derived_num(std::map v) { + return derived_num3(v); +} + +int base_num(BasePtr v) { + return base_num1(v); +} + +int base_num(std::vector v) { + return base_num2(v); +} + +int base_num(std::map v) { + return base_num3(v); +} %} @@ -88,10 +113,18 @@ public: typedef std::shared_ptr BasePtr; typedef std::shared_ptr DerivedPtr; +// non-overloaded +int derived_num1(DerivedPtr); +int derived_num2(std::vector > v); +int derived_num3(std::map v); +int base_num1(BasePtr); +int base_num2(std::vector > v); +int base_num3(std::map v); + +// overloaded int derived_num(DerivedPtr); int derived_num(std::vector > v); int derived_num(std::map v); int base_num(BasePtr); int base_num(std::vector > v); int base_num(std::map v); - diff --git a/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb b/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb index 188f9ccbf..ef83ab367 100644 --- a/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb +++ b/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb @@ -4,9 +4,20 @@ require 'cpp11_shared_ptr_upcast' include Cpp11_shared_ptr_upcast +# non-overloaded +simple_assert_equal( 7, derived_num1(Derived.new(7)) ) +simple_assert_equal( 7, derived_num2([Derived.new(7)]) ) +simple_assert_equal( 7, derived_num3({0 => Derived.new(7)}) ) + +simple_assert_equal(-1, base_num1(Derived.new(7)) ) +simple_assert_equal(-1, base_num2([Derived.new(7)]) ) +simple_assert_equal(-1, base_num3({0 => Derived.new(7)}) ) + +# overloaded simple_assert_equal( 7, derived_num(Derived.new(7)) ) simple_assert_equal( 7, derived_num([Derived.new(7)]) ) simple_assert_equal( 7, derived_num({0 => Derived.new(7)}) ) + simple_assert_equal(-1, base_num(Derived.new(7)) ) simple_assert_equal(-1, base_num([Derived.new(7)]) ) simple_assert_equal(-1, base_num({0 => Derived.new(7)}) ) From 83a389d3fbccbd588f3a649c4a736feeae617341 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Wed, 12 Apr 2017 19:08:23 +0100 Subject: [PATCH 12/16] Add support for pointers to shared_ptr and null shared_ptr in Ruby containers Upcasting of pointers to shared_ptr would need some more fundamental changes, but not done yet ... pointers to shared_ptr are not common. --- Examples/test-suite/cpp11_shared_ptr_upcast.i | 70 +++++++++++++-- .../ruby/cpp11_shared_ptr_upcast_runme.rb | 37 ++++++++ Lib/ruby/std_shared_ptr.i | 85 +++++++++++++------ 3 files changed, 160 insertions(+), 32 deletions(-) diff --git a/Examples/test-suite/cpp11_shared_ptr_upcast.i b/Examples/test-suite/cpp11_shared_ptr_upcast.i index 9f65eb7e1..3427829d9 100644 --- a/Examples/test-suite/cpp11_shared_ptr_upcast.i +++ b/Examples/test-suite/cpp11_shared_ptr_upcast.i @@ -36,27 +36,27 @@ typedef std::shared_ptr DerivedPtr; // non-overloaded int derived_num1(DerivedPtr v) { - return (*v).get_n(); + return v == nullptr ? 999 : (*v).get_n(); } int derived_num2(std::vector v) { - return (*v[0]).get_n(); + return v[0] == nullptr ? 999 : (*v[0]).get_n(); } int derived_num3(std::map v) { - return (*v[0]).get_n(); + return v[0] == nullptr ? 999 : (*v[0]).get_n(); } int base_num1(BasePtr v) { - return (*v).get_m(); + return v == nullptr ? 999 : (*v).get_m(); } int base_num2(std::vector v) { - return (*v[0]).get_m(); + return v[0] == nullptr ? 999 : (*v[0]).get_m(); } int base_num3(std::map v) { - return (*v[0]).get_m(); + return v[0] == nullptr ? 999 : (*v[0]).get_m(); } // overloaded @@ -128,3 +128,61 @@ int derived_num(std::map v); int base_num(BasePtr); int base_num(std::vector > v); int base_num(std::map v); + +// ptr to shared_ptr +%shared_ptr(Base2); +%shared_ptr(Derived2) + +%inline %{ +class Base2 { +public: + Base2() : m(-1) {} + Base2(int i) : m(i) {} + int get_m() { return m; } + int m; +}; + + +class Derived2 : public Base2 { +public: + Derived2() : n(0) {} + Derived2(int i) : n(i) {} + int get_n_2() { return n; } + int n; +}; +%} + +%template(Base2List) std::vector * >; +%template(Base2Map) std::map * >; + +%template(Derived2List) std::vector * >; +%template(Derived2Map) std::map * >; + +%inline %{ +typedef std::shared_ptr * Derived2Ptr; +typedef std::shared_ptr * Base2Ptr; + +int base2_num1(Base2Ptr v) { + return v == nullptr ? 999 : *v == nullptr ? 888 : (*v)->get_m(); +} + +int base2_num2(std::vector v) { + return v[0] == nullptr ? 999 : *v[0] == nullptr ? 888 : (*v[0])->get_m(); +} + +int base2_num3(std::map v) { + return v[0] == nullptr ? 999 : *v[0] == nullptr ? 888 : (*v[0])->get_m(); +} + +int derived2_num1(Derived2Ptr v) { + return v == nullptr ? 999 : *v == nullptr ? 888 : (*v)->get_n_2(); +} + +int derived2_num2(std::vector v) { + return v[0] == nullptr ? 999 : *v[0] == nullptr ? 888 : (*v[0])->get_n_2(); +} + +int derived2_num3(std::map v) { + return v[0] == nullptr ? 999 : *v[0] == nullptr ? 888 : (*v[0])->get_n_2(); +} +%} diff --git a/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb b/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb index ef83ab367..864be1382 100644 --- a/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb +++ b/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb @@ -13,6 +13,14 @@ simple_assert_equal(-1, base_num1(Derived.new(7)) ) simple_assert_equal(-1, base_num2([Derived.new(7)]) ) simple_assert_equal(-1, base_num3({0 => Derived.new(7)}) ) +simple_assert_equal( 999, derived_num1(nil) ) +simple_assert_equal( 999, derived_num2([nil]) ) +simple_assert_equal( 999, derived_num3({0 => nil}) ) + +simple_assert_equal( 999, base_num1(nil) ) +simple_assert_equal( 999, base_num2([nil]) ) +simple_assert_equal( 999, base_num3({0 => nil}) ) + # overloaded simple_assert_equal( 7, derived_num(Derived.new(7)) ) simple_assert_equal( 7, derived_num([Derived.new(7)]) ) @@ -21,3 +29,32 @@ simple_assert_equal( 7, derived_num({0 => Derived.new(7)}) ) simple_assert_equal(-1, base_num(Derived.new(7)) ) simple_assert_equal(-1, base_num([Derived.new(7)]) ) simple_assert_equal(-1, base_num({0 => Derived.new(7)}) ) + +# ptr to shared_ptr +simple_assert_equal( 7, derived2_num1(Derived2.new(7)) ) +simple_assert_equal( 7, derived2_num2([Derived2.new(7)]) ) +simple_assert_equal( 7, derived2_num3({0 => Derived2.new(7)}) ) + +simple_assert_equal( -1, base2_num1(Derived2.new(7)) ) + +begin + # Upcast for pointers to shared_ptr in this generic framework has not been implemented + simple_assert_equal( -1, base2_num2([Derived2.new(7)]) ) + raise RuntimeError, "Failed to catch TypeError" +rescue TypeError +end +begin + # Upcast for pointers to shared_ptr in this generic framework has not been implemented + simple_assert_equal( -1, base2_num3({0 => Derived2.new(7)}) ) + raise RuntimeError, "Failed to catch TypeError" +rescue TypeError +end + +simple_assert_equal( 888, derived2_num1(nil) ) +simple_assert_equal( 999, derived2_num2([nil]) ) # although 888 would be more consistent +simple_assert_equal( 999, derived2_num3({0 => nil}) ) # although 888 would be more consistent + +simple_assert_equal( 888, base2_num1(nil) ) +simple_assert_equal( 999, base2_num2([nil]) ) # although 888 would be more consistent +simple_assert_equal( 999, base2_num3({0 => nil}) ) # although 888 would be more consistent + diff --git a/Lib/ruby/std_shared_ptr.i b/Lib/ruby/std_shared_ptr.i index 5d56b8750..4e0798d56 100644 --- a/Lib/ruby/std_shared_ptr.i +++ b/Lib/ruby/std_shared_ptr.i @@ -7,23 +7,32 @@ { namespace swig { /* - template specialization for functions defined in rubystdcommon.swg. - here we should treat smart pointers in a way different from the way we treat raw pointers. + Template specialization for functions defined in rubystdcommon.swg. Special handling for shared_ptr + is required as, shared_ptr * is used rather than the usual T *, see shared_ptr.i. */ template struct traits_asptr > { static int asptr(VALUE obj, std::shared_ptr **val) { - std::shared_ptr *p=0; + std::shared_ptr *p = 0; swig_type_info *descriptor = type_info >(); swig_ruby_owntype newmem = {0, 0}; int res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR; - if (SWIG_IsOK(res) && p) { - if (val && *val) **val = *p; - if (newmem.own & SWIG_CAST_NEW_MEMORY) delete p; - return SWIG_OK; - } else { - return SWIG_ERROR; + if (SWIG_IsOK(res)) { + if (val) { + if (*val) { + **val = p ? *p : std::shared_ptr(); + } else { + *val = p; + if (newmem.own & SWIG_CAST_NEW_MEMORY) { + // Upcast for pointers to shared_ptr in this generic framework has not been implemented + res = SWIG_ERROR; + } + } + } + if (newmem.own & SWIG_CAST_NEW_MEMORY) + delete p; } + return res; } }; @@ -31,12 +40,13 @@ namespace swig { struct traits_asval > { static int asval(VALUE obj, std::shared_ptr *val) { if (val) { - std::shared_ptr ret; - std::shared_ptr *p=&ret; + std::shared_ptr ret; + std::shared_ptr *p = &ret; int res = traits_asptr >::asptr(obj, &p); - if (!SWIG_IsOK(res)) return res; - if (val) *val = ret; - return SWIG_OK; + if (!SWIG_IsOK(res)) + return res; + *val = ret; + return SWIG_OK; } else { return traits_asptr >::asptr(obj, (std::shared_ptr **)(0)); } @@ -44,17 +54,24 @@ namespace swig { }; template - struct traits_asval*> { + struct traits_asval *> { static int asval(VALUE obj, std::shared_ptr **val) { - if (val && *val) { - typedef typename noconst_traits >::noconst_type noconst_type; - noconst_type ret; - noconst_type *p = &ret; - int res = traits_asptr::asptr(obj, &p); - if (SWIG_IsOK(res)) { - **(const_cast(val)) = ret; + if (val) { + typedef typename noconst_traits >::noconst_type noconst_type; + if (*val) { + noconst_type ret; + noconst_type *p = &ret; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) + **(const_cast(val)) = ret; + return res; + } else { + noconst_type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) + *val = p; + return res; } - return res; } else { return traits_asptr >::asptr(obj, (std::shared_ptr **)(0)); } @@ -73,16 +90,32 @@ namespace swig { // Uninitialized return value, no Type() constructor required. if (throw_error) throw std::invalid_argument("bad type"); VALUE lastErr = rb_gv_get("$!"); - if (lastErr == Qnil) { + if (lastErr == Qnil) SWIG_Error(SWIG_TypeError, swig::type_name >()); - } - static std::shared_ptr *v_def = (std::shared_ptr*) malloc(sizeof(std::shared_ptr)); + static std::shared_ptr *v_def = (std::shared_ptr *) malloc(sizeof(std::shared_ptr)); memset(v_def,0,sizeof(std::shared_ptr)); return *v_def; } } }; + template + struct traits_as *, pointer_category> { + static std::shared_ptr * as(VALUE obj, bool throw_error) { + std::shared_ptr *p = 0; + int res = traits_asptr >::asptr(obj, &p); + if (SWIG_IsOK(res)) { + return p; + } else { + if (throw_error) throw std::invalid_argument("bad type"); + VALUE lastErr = rb_gv_get("$!"); + if (lastErr == Qnil) + SWIG_Error(SWIG_TypeError, swig::type_name *>()); + return 0; + } + } + }; + /* we have to remove the const qualifier to work around a BUG SWIG_TypeQuery("std::shared_ptr") == NULL, From 1a6f8d1e4b350a8245bf3c355c76825bf7bfaaf8 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 13 Apr 2017 07:04:07 +0100 Subject: [PATCH 13/16] Ruby shared_ptr on error code improvement in traits_as::as --- Lib/ruby/std_shared_ptr.i | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Lib/ruby/std_shared_ptr.i b/Lib/ruby/std_shared_ptr.i index 4e0798d56..983ffde49 100644 --- a/Lib/ruby/std_shared_ptr.i +++ b/Lib/ruby/std_shared_ptr.i @@ -87,14 +87,11 @@ namespace swig { if (SWIG_IsOK(res)) { return ret; } else { - // Uninitialized return value, no Type() constructor required. if (throw_error) throw std::invalid_argument("bad type"); VALUE lastErr = rb_gv_get("$!"); if (lastErr == Qnil) SWIG_Error(SWIG_TypeError, swig::type_name >()); - static std::shared_ptr *v_def = (std::shared_ptr *) malloc(sizeof(std::shared_ptr)); - memset(v_def,0,sizeof(std::shared_ptr)); - return *v_def; + return std::shared_ptr(); } } }; From 7a343a196bc74dad5acce107d2c709974b7535d9 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 20 Apr 2017 07:33:15 +0100 Subject: [PATCH 14/16] Correct ordering of declarations in testcase --- Examples/test-suite/cpp11_shared_ptr_const.i | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Examples/test-suite/cpp11_shared_ptr_const.i b/Examples/test-suite/cpp11_shared_ptr_const.i index 1989e3261..0d1acdac0 100644 --- a/Examples/test-suite/cpp11_shared_ptr_const.i +++ b/Examples/test-suite/cpp11_shared_ptr_const.i @@ -43,11 +43,6 @@ std::vector > const_foo_vec(Foo v) { %template (FooVector) std::vector >; %template (FooConstVector) std::vector >; -std::shared_ptr foo(Foo v); -std::shared_ptr const_foo(Foo v); -std::vector > foo_vec(Foo v) const; -std::vector > const_foo_vec(Foo v) const; - class Foo { public: @@ -55,3 +50,8 @@ public: int get_m(); int m; }; +std::shared_ptr foo(Foo v); +std::shared_ptr const_foo(Foo v); +std::vector > foo_vec(Foo v) const; +std::vector > const_foo_vec(Foo v) const; + From 660147043da845998e9066d7116aaf3f525b56e5 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 20 Apr 2017 07:49:03 +0100 Subject: [PATCH 15/16] Correct comment about const removal for shared_ptr --- Lib/ruby/std_shared_ptr.i | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Lib/ruby/std_shared_ptr.i b/Lib/ruby/std_shared_ptr.i index 983ffde49..f6c0a15ac 100644 --- a/Lib/ruby/std_shared_ptr.i +++ b/Lib/ruby/std_shared_ptr.i @@ -114,9 +114,8 @@ namespace swig { }; /* - we have to remove the const qualifier to work around a BUG - SWIG_TypeQuery("std::shared_ptr") == NULL, - which is caused by %template treating const qualifiers not properly. + The descriptors in the shared_ptr typemaps remove the const qualifier for the SWIG type system. + Remove const likewise here, otherwise SWIG_TypeQuery("std::shared_ptr") will return NULL. */ template struct traits_from > { @@ -128,5 +127,4 @@ namespace swig { } } -//force the fragment. %fragment("StdSharedPtrTraits"); From 6398614c9278db40d41dca630a672bcb39835276 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 20 Apr 2017 07:57:48 +0100 Subject: [PATCH 16/16] Update ruby tests for change in swig_assert_equal_simple name --- .../ruby/cpp11_shared_ptr_const_runme.rb | 8 +-- .../ruby/cpp11_shared_ptr_upcast_runme.rb | 60 +++++++++---------- 2 files changed, 34 insertions(+), 34 deletions(-) diff --git a/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb b/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb index db56252da..149aa0898 100644 --- a/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb +++ b/Examples/test-suite/ruby/cpp11_shared_ptr_const_runme.rb @@ -3,7 +3,7 @@ require "cpp11_shared_ptr_const" include Cpp11_shared_ptr_const -simple_assert_equal(1, foo( Foo.new(1) ).get_m ) -simple_assert_equal(7, const_foo( Foo.new(7) ).get_m ) -simple_assert_equal(7, foo_vec( Foo.new(7) )[0].get_m ) -simple_assert_equal(8, const_foo_vec( Foo.new(8) )[0].get_m ) +swig_assert_equal_simple(1, foo( Foo.new(1) ).get_m ) +swig_assert_equal_simple(7, const_foo( Foo.new(7) ).get_m ) +swig_assert_equal_simple(7, foo_vec( Foo.new(7) )[0].get_m ) +swig_assert_equal_simple(8, const_foo_vec( Foo.new(8) )[0].get_m ) diff --git a/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb b/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb index 864be1382..000b9b6a9 100644 --- a/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb +++ b/Examples/test-suite/ruby/cpp11_shared_ptr_upcast_runme.rb @@ -5,56 +5,56 @@ require 'cpp11_shared_ptr_upcast' include Cpp11_shared_ptr_upcast # non-overloaded -simple_assert_equal( 7, derived_num1(Derived.new(7)) ) -simple_assert_equal( 7, derived_num2([Derived.new(7)]) ) -simple_assert_equal( 7, derived_num3({0 => Derived.new(7)}) ) +swig_assert_equal_simple( 7, derived_num1(Derived.new(7)) ) +swig_assert_equal_simple( 7, derived_num2([Derived.new(7)]) ) +swig_assert_equal_simple( 7, derived_num3({0 => Derived.new(7)}) ) -simple_assert_equal(-1, base_num1(Derived.new(7)) ) -simple_assert_equal(-1, base_num2([Derived.new(7)]) ) -simple_assert_equal(-1, base_num3({0 => Derived.new(7)}) ) +swig_assert_equal_simple(-1, base_num1(Derived.new(7)) ) +swig_assert_equal_simple(-1, base_num2([Derived.new(7)]) ) +swig_assert_equal_simple(-1, base_num3({0 => Derived.new(7)}) ) -simple_assert_equal( 999, derived_num1(nil) ) -simple_assert_equal( 999, derived_num2([nil]) ) -simple_assert_equal( 999, derived_num3({0 => nil}) ) +swig_assert_equal_simple( 999, derived_num1(nil) ) +swig_assert_equal_simple( 999, derived_num2([nil]) ) +swig_assert_equal_simple( 999, derived_num3({0 => nil}) ) -simple_assert_equal( 999, base_num1(nil) ) -simple_assert_equal( 999, base_num2([nil]) ) -simple_assert_equal( 999, base_num3({0 => nil}) ) +swig_assert_equal_simple( 999, base_num1(nil) ) +swig_assert_equal_simple( 999, base_num2([nil]) ) +swig_assert_equal_simple( 999, base_num3({0 => nil}) ) # overloaded -simple_assert_equal( 7, derived_num(Derived.new(7)) ) -simple_assert_equal( 7, derived_num([Derived.new(7)]) ) -simple_assert_equal( 7, derived_num({0 => Derived.new(7)}) ) +swig_assert_equal_simple( 7, derived_num(Derived.new(7)) ) +swig_assert_equal_simple( 7, derived_num([Derived.new(7)]) ) +swig_assert_equal_simple( 7, derived_num({0 => Derived.new(7)}) ) -simple_assert_equal(-1, base_num(Derived.new(7)) ) -simple_assert_equal(-1, base_num([Derived.new(7)]) ) -simple_assert_equal(-1, base_num({0 => Derived.new(7)}) ) +swig_assert_equal_simple(-1, base_num(Derived.new(7)) ) +swig_assert_equal_simple(-1, base_num([Derived.new(7)]) ) +swig_assert_equal_simple(-1, base_num({0 => Derived.new(7)}) ) # ptr to shared_ptr -simple_assert_equal( 7, derived2_num1(Derived2.new(7)) ) -simple_assert_equal( 7, derived2_num2([Derived2.new(7)]) ) -simple_assert_equal( 7, derived2_num3({0 => Derived2.new(7)}) ) +swig_assert_equal_simple( 7, derived2_num1(Derived2.new(7)) ) +swig_assert_equal_simple( 7, derived2_num2([Derived2.new(7)]) ) +swig_assert_equal_simple( 7, derived2_num3({0 => Derived2.new(7)}) ) -simple_assert_equal( -1, base2_num1(Derived2.new(7)) ) +swig_assert_equal_simple( -1, base2_num1(Derived2.new(7)) ) begin # Upcast for pointers to shared_ptr in this generic framework has not been implemented - simple_assert_equal( -1, base2_num2([Derived2.new(7)]) ) + swig_assert_equal_simple( -1, base2_num2([Derived2.new(7)]) ) raise RuntimeError, "Failed to catch TypeError" rescue TypeError end begin # Upcast for pointers to shared_ptr in this generic framework has not been implemented - simple_assert_equal( -1, base2_num3({0 => Derived2.new(7)}) ) + swig_assert_equal_simple( -1, base2_num3({0 => Derived2.new(7)}) ) raise RuntimeError, "Failed to catch TypeError" rescue TypeError end -simple_assert_equal( 888, derived2_num1(nil) ) -simple_assert_equal( 999, derived2_num2([nil]) ) # although 888 would be more consistent -simple_assert_equal( 999, derived2_num3({0 => nil}) ) # although 888 would be more consistent +swig_assert_equal_simple( 888, derived2_num1(nil) ) +swig_assert_equal_simple( 999, derived2_num2([nil]) ) # although 888 would be more consistent +swig_assert_equal_simple( 999, derived2_num3({0 => nil}) ) # although 888 would be more consistent -simple_assert_equal( 888, base2_num1(nil) ) -simple_assert_equal( 999, base2_num2([nil]) ) # although 888 would be more consistent -simple_assert_equal( 999, base2_num3({0 => nil}) ) # although 888 would be more consistent +swig_assert_equal_simple( 888, base2_num1(nil) ) +swig_assert_equal_simple( 999, base2_num2([nil]) ) # although 888 would be more consistent +swig_assert_equal_simple( 999, base2_num3({0 => nil}) ) # although 888 would be more consistent