From 0f18b430fb39d44e126f9f981462c47fca7b8dba Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Wed, 21 Nov 2018 19:19:15 -0500 Subject: [PATCH 01/26] Add unordered_{set|map} and set to Java Add test suite Add to makefile Revert set change Fix java map test Fix some of the tests Fix unordered map test --- Examples/test-suite/java/Makefile.in | 4 + .../test-suite/java/li_std_map_runme.java | 101 ++++++++++++++++++ .../test-suite/java/li_std_set_runme.java | 40 +++++++ .../java/li_std_unordered_map_runme.java | 101 ++++++++++++++++++ .../java/li_std_unordered_set_runme.java | 40 +++++++ Examples/test-suite/li_std_set.i | 25 ++--- Examples/test-suite/li_std_unordered_map.i | 12 +++ Examples/test-suite/li_std_unordered_set.i | 11 ++ Lib/java/std_set.i | 47 ++++++++ Lib/java/std_unordered_map.i | 65 +++++++++++ Lib/java/std_unordered_set.i | 47 ++++++++ 11 files changed, 481 insertions(+), 12 deletions(-) create mode 100644 Examples/test-suite/java/li_std_map_runme.java create mode 100644 Examples/test-suite/java/li_std_set_runme.java create mode 100644 Examples/test-suite/java/li_std_unordered_map_runme.java create mode 100644 Examples/test-suite/java/li_std_unordered_set_runme.java create mode 100644 Examples/test-suite/li_std_unordered_map.i create mode 100644 Examples/test-suite/li_std_unordered_set.i create mode 100644 Lib/java/std_set.i create mode 100644 Lib/java/std_unordered_map.i create mode 100644 Lib/java/std_unordered_set.i diff --git a/Examples/test-suite/java/Makefile.in b/Examples/test-suite/java/Makefile.in index 8a98172ed..acb0ef2e3 100644 --- a/Examples/test-suite/java/Makefile.in +++ b/Examples/test-suite/java/Makefile.in @@ -44,6 +44,10 @@ CPP_TEST_CASES = \ java_typemaps_proxy \ java_typemaps_typewrapper \ li_std_list \ + li_std_map \ + li_std_set \ + li_std_unordered_map \ + li_std_unordered_set \ # li_boost_intrusive_ptr CPP11_TEST_CASES = \ diff --git a/Examples/test-suite/java/li_std_map_runme.java b/Examples/test-suite/java/li_std_map_runme.java new file mode 100644 index 000000000..3cc794ced --- /dev/null +++ b/Examples/test-suite/java/li_std_map_runme.java @@ -0,0 +1,101 @@ +import li_std_map.*; + +public class li_std_map_runme { + + static { + try { + System.loadLibrary("li_std_map"); + } catch (UnsatisfiedLinkError e) { + System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); + System.exit(1); + } + } + + public static void main(String argv[]) throws Throwable + { + StringIntMap sim = new StringIntMap(); + IntIntMap iim = new IntIntMap(); + + if (!sim.empty()) throw new RuntimeException("Test (1) failed"); + if (!iim.empty()) throw new RuntimeException("Test (2) failed"); + + if (sim.size() != 0) throw new RuntimeException("Test (3) failed"); + if (iim.size() != 0) throw new RuntimeException("Test (4) failed"); + + try { + sim.get("key"); + throw new RuntimeException("Test (5) failed"); + } catch (IndexOutOfBoundsException e) { + } + + try { + iim.get(1); + throw new RuntimeException("Test (6) failed"); + } catch (IndexOutOfBoundsException e) { + } + + sim.set("key", 1); + iim.set(1, 1); + + if (sim.size() != 1) throw new RuntimeException("Test (7) failed"); + if (iim.size() != 1) throw new RuntimeException("Test (8) failed"); + + sim.del("key"); + iim.del(1); + + if (sim.has_key("key")) throw new RuntimeException("Test (9) failed"); + if (iim.has_key(1)) throw new RuntimeException("Test (10) failed"); + + if (!sim.empty()) throw new RuntimeException("Test (11) failed"); + if (!iim.empty()) throw new RuntimeException("Test (12) failed"); + if (sim.size() != 0) throw new RuntimeException("Test (13) failed"); + if (iim.size() != 0) throw new RuntimeException("Test (14) failed"); + + try { + sim.del("key"); + throw new RuntimeException("Test (15) failed"); + } catch (IndexOutOfBoundsException e) { + } + + try { + iim.del(1); + throw new RuntimeException("Test (16) failed"); + } catch (IndexOutOfBoundsException e) { + } + + sim.set("key", 1); + iim.set(1, 1); + + if (sim.size() != 1) throw new RuntimeException("Test (17) failed"); + if (iim.size() != 1) throw new RuntimeException("Test (18) failed"); + + sim.clear(); + iim.clear(); + + if (sim.has_key("key")) throw new RuntimeException("Test (19) failed"); + if (iim.has_key(1)) throw new RuntimeException("Test (20) failed"); + + if (!sim.empty()) throw new RuntimeException("Test (21) failed"); + if (!iim.empty()) throw new RuntimeException("Test (22) failed"); + if (sim.size() != 0) throw new RuntimeException("Test (23) failed"); + if (iim.size() != 0) throw new RuntimeException("Test (24) failed"); + + sim.set("key", 1); + sim.set("key2", 2); + iim.set(1, 1); + iim.set(2, 2); + + if (sim.get("key") != 1) throw new RuntimeException("Test (25) failed"); + if (sim.get("key2") != 2) throw new RuntimeException("Test (26) failed"); + if (iim.get(1) != 1) throw new RuntimeException("Test (27) failed"); + if (iim.get(2) != 2) throw new RuntimeException("Test (28) failed"); + + sim.set("key", 3); + iim.set(1, 3); + + if (sim.get("key") != 3) throw new RuntimeException("Test (29) failed"); + if (sim.get("key2") != 2) throw new RuntimeException("Test (30) failed"); + if (iim.get(1) != 3) throw new RuntimeException("Test (31) failed"); + if (iim.get(2) != 2) throw new RuntimeException("Test (32) failed"); + } +} diff --git a/Examples/test-suite/java/li_std_set_runme.java b/Examples/test-suite/java/li_std_set_runme.java new file mode 100644 index 000000000..61edd93dc --- /dev/null +++ b/Examples/test-suite/java/li_std_set_runme.java @@ -0,0 +1,40 @@ +import li_std_set.*; + +public class li_std_set_runme { + + static { + try { + System.loadLibrary("li_std_set"); + } catch (UnsatisfiedLinkError e) { + System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); + System.exit(1); + } + } + + public static void main(String argv[]) throws Throwable + { + StringSet ss = new StringSet(); + + if (!ss.empty()) throw new RuntimeException("Test (1) failed"); + if (ss.size() != 0) throw new RuntimeException("Test (2) failed"); + if (ss.has("key")) throw new RuntimeException("Test (3) failed"); + if (ss.erase("key")) throw new RuntimeException("Test (4) failed"); + + if (!ss.insert("key")) throw new RuntimeException("Test (5) failed"); + if (ss.insert("key")) throw new RuntimeException("Test (6) failed"); + if (!ss.has("key")) throw new RuntimeException("Test (7) failed"); + + if (!ss.erase("key")) throw new RuntimeException("Test (8) failed"); + if (!ss.empty()) throw new RuntimeException("Test (9) failed"); + if (ss.size() != 0) throw new RuntimeException("Test (10) failed"); + + if (!ss.insert("key1")) throw new RuntimeException("Test (11) failed"); + if (!ss.insert("key2")) throw new RuntimeException("Test (12) failed"); + if (!ss.insert("key3")) throw new RuntimeException("Test (13) failed"); + if (ss.size() != 3) throw new RuntimeException("Test (14) failed"); + + ss.clear(); + if (!ss.empty()) throw new RuntimeException("Test (15) failed"); + if (ss.size() != 0) throw new RuntimeException("Test (16) failed"); + } +} diff --git a/Examples/test-suite/java/li_std_unordered_map_runme.java b/Examples/test-suite/java/li_std_unordered_map_runme.java new file mode 100644 index 000000000..8ab6f23e4 --- /dev/null +++ b/Examples/test-suite/java/li_std_unordered_map_runme.java @@ -0,0 +1,101 @@ +import li_std_unordered_map.*; + +public class li_std_unordered_map_runme { + + static { + try { + System.loadLibrary("li_std_unordered_map"); + } catch (UnsatisfiedLinkError e) { + System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); + System.exit(1); + } + } + + public static void main(String argv[]) throws Throwable + { + StringIntUnorderedMap sim = new StringIntUnorderedMap(); + IntIntUnorderedMap iim = new IntIntUnorderedMap(); + + if (!sim.empty()) throw new RuntimeException("Test (1) failed"); + if (!iim.empty()) throw new RuntimeException("Test (2) failed"); + + if (sim.size() != 0) throw new RuntimeException("Test (3) failed"); + if (iim.size() != 0) throw new RuntimeException("Test (4) failed"); + + try { + sim.get("key"); + throw new RuntimeException("Test (5) failed"); + } catch (IndexOutOfBoundsException e) { + } + + try { + iim.get(1); + throw new RuntimeException("Test (6) failed"); + } catch (IndexOutOfBoundsException e) { + } + + sim.set("key", 1); + iim.set(1, 1); + + if (sim.size() != 1) throw new RuntimeException("Test (7) failed"); + if (iim.size() != 1) throw new RuntimeException("Test (8) failed"); + + sim.del("key"); + iim.del(1); + + if (sim.has_key("key")) throw new RuntimeException("Test (9) failed"); + if (iim.has_key(1)) throw new RuntimeException("Test (10) failed"); + + if (!sim.empty()) throw new RuntimeException("Test (11) failed"); + if (!iim.empty()) throw new RuntimeException("Test (12) failed"); + if (sim.size() != 0) throw new RuntimeException("Test (13) failed"); + if (iim.size() != 0) throw new RuntimeException("Test (14) failed"); + + try { + sim.del("key"); + throw new RuntimeException("Test (15) failed"); + } catch (IndexOutOfBoundsException e) { + } + + try { + iim.del(1); + throw new RuntimeException("Test (16) failed"); + } catch (IndexOutOfBoundsException e) { + } + + sim.set("key", 1); + iim.set(1, 1); + + if (sim.size() != 1) throw new RuntimeException("Test (17) failed"); + if (iim.size() != 1) throw new RuntimeException("Test (18) failed"); + + sim.clear(); + iim.clear(); + + if (sim.has_key("key")) throw new RuntimeException("Test (19) failed"); + if (iim.has_key(1)) throw new RuntimeException("Test (20) failed"); + + if (!sim.empty()) throw new RuntimeException("Test (21) failed"); + if (!iim.empty()) throw new RuntimeException("Test (22) failed"); + if (sim.size() != 0) throw new RuntimeException("Test (23) failed"); + if (iim.size() != 0) throw new RuntimeException("Test (24) failed"); + + sim.set("key", 1); + sim.set("key2", 2); + iim.set(1, 1); + iim.set(2, 2); + + if (sim.get("key") != 1) throw new RuntimeException("Test (25) failed"); + if (sim.get("key2") != 2) throw new RuntimeException("Test (26) failed"); + if (iim.get(1) != 1) throw new RuntimeException("Test (27) failed"); + if (iim.get(2) != 2) throw new RuntimeException("Test (28) failed"); + + sim.set("key", 3); + iim.set(1, 3); + + if (sim.get("key") != 3) throw new RuntimeException("Test (29) failed"); + if (sim.get("key2") != 2) throw new RuntimeException("Test (30) failed"); + if (iim.get(1) != 3) throw new RuntimeException("Test (31) failed"); + if (iim.get(2) != 2) throw new RuntimeException("Test (32) failed"); + } +} diff --git a/Examples/test-suite/java/li_std_unordered_set_runme.java b/Examples/test-suite/java/li_std_unordered_set_runme.java new file mode 100644 index 000000000..ce94f8fe4 --- /dev/null +++ b/Examples/test-suite/java/li_std_unordered_set_runme.java @@ -0,0 +1,40 @@ +import li_std_unordered_set.*; + +public class li_std_unordered_set_runme { + + static { + try { + System.loadLibrary("li_std_unordered_set"); + } catch (UnsatisfiedLinkError e) { + System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); + System.exit(1); + } + } + + public static void main(String argv[]) throws Throwable + { + StringUnorderedSet ss = new StringUnorderedSet(); + + if (!ss.empty()) throw new RuntimeException("Test (1) failed"); + if (ss.size() != 0) throw new RuntimeException("Test (2) failed"); + if (ss.has("key")) throw new RuntimeException("Test (3) failed"); + if (ss.erase("key")) throw new RuntimeException("Test (4) failed"); + + if (!ss.insert("key")) throw new RuntimeException("Test (5) failed"); + if (ss.insert("key")) throw new RuntimeException("Test (6) failed"); + if (!ss.has("key")) throw new RuntimeException("Test (7) failed"); + + if (!ss.erase("key")) throw new RuntimeException("Test (8) failed"); + if (!ss.empty()) throw new RuntimeException("Test (9) failed"); + if (ss.size() != 0) throw new RuntimeException("Test (10) failed"); + + if (!ss.insert("key1")) throw new RuntimeException("Test (11) failed"); + if (!ss.insert("key2")) throw new RuntimeException("Test (12) failed"); + if (!ss.insert("key3")) throw new RuntimeException("Test (13) failed"); + if (ss.size() != 3) throw new RuntimeException("Test (14) failed"); + + ss.clear(); + if (!ss.empty()) throw new RuntimeException("Test (15) failed"); + if (ss.size() != 0) throw new RuntimeException("Test (16) failed"); + } +} diff --git a/Examples/test-suite/li_std_set.i b/Examples/test-suite/li_std_set.i index 2dcc2f17c..fc9db42a9 100644 --- a/Examples/test-suite/li_std_set.i +++ b/Examples/test-suite/li_std_set.i @@ -1,5 +1,5 @@ /* - * a test of set containers. + * a test of set containers. * Languages should define swig::LANGUAGE_OBJ to be * an entity of their native pointer type which can be * included in a STL container. @@ -13,22 +13,23 @@ %include %include -%include %include -%template(set_string) std::set; -%template(set_int) std::multiset; - - -%template(v_int) std::vector; - - - +// Use language macros since Java doesn't have multiset support (yet) +// and uses different naming conventions. +#if defined(SWIGRUBY) || defined(SWIGPYTHON) + %include + %template(set_int) std::multiset; + %template(v_int) std::vector; + %template(set_string) std::set; +#elif defined(SWIGJAVA) + %template(StringSet) std::set; +#endif #if defined(SWIGRUBY) -%template(LanguageSet) std::set; +%template(LanguageSet) std::set; #endif #if defined(SWIGPYTHON) -%template(pyset) std::set; +%template(pyset) std::set; #endif diff --git a/Examples/test-suite/li_std_unordered_map.i b/Examples/test-suite/li_std_unordered_map.i new file mode 100644 index 000000000..a6869cc0b --- /dev/null +++ b/Examples/test-suite/li_std_unordered_map.i @@ -0,0 +1,12 @@ +/* + * A test of unordered_map containers. + */ + +%module li_std_unordered_map + +%include +%include + +%template(IntIntUnorderedMap) std::unordered_map; +%template(StringIntUnorderedMap) std::unordered_map; + diff --git a/Examples/test-suite/li_std_unordered_set.i b/Examples/test-suite/li_std_unordered_set.i new file mode 100644 index 000000000..a051e9389 --- /dev/null +++ b/Examples/test-suite/li_std_unordered_set.i @@ -0,0 +1,11 @@ +/* + * A test of unordered_set containers. + */ + +%module li_std_unordered_set + +%include +%include + +%template(StringUnorderedSet) std::unordered_set; + diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i new file mode 100644 index 000000000..8c4bb7f17 --- /dev/null +++ b/Lib/java/std_set.i @@ -0,0 +1,47 @@ +/* ----------------------------------------------------------------------------- + * std_set.i + * + * SWIG typemaps for std::set + * ----------------------------------------------------------------------------- */ + +%include + +// ------------------------------------------------------------------------ +// std::set +// ------------------------------------------------------------------------ + +%{ +#include +%} + +namespace std { + +template +class set { + public: + set(); + set(const set&); + + unsigned int size() const; + bool empty() const; + void clear(); + + %extend { + // Returns whether item was inserted. + bool insert(const KeyType& key) { + return self->insert(key).second; + } + + // Returns whether set contains key. + bool has(const KeyType& key) { + return (self->count(key) > 0); + } + + // Returns whether the item was erased. + bool erase(const KeyType& key) { + return (self->erase(key) > 0); + } + } +}; + +} // namespace std \ No newline at end of file diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i new file mode 100644 index 000000000..434292b07 --- /dev/null +++ b/Lib/java/std_unordered_map.i @@ -0,0 +1,65 @@ +/* ----------------------------------------------------------------------------- + * std_unordered_map.i + * + * SWIG typemaps for std::unordered_map + * ----------------------------------------------------------------------------- */ + +%include + +// ------------------------------------------------------------------------ +// std::unordered_map +// ------------------------------------------------------------------------ + +%{ +#include +#include +%} + +namespace std { + +template class unordered_map { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef KeyType key_type; + typedef MappedType mapped_type; + unordered_map(); + unordered_map(const unordered_map&); + + unsigned int size() const; + bool empty() const; + void clear(); + + %extend { + const MappedType& get(const KeyType& key) throw (std::out_of_range) { + std::unordered_map::iterator i = self->find(key); + + if (i != self->end()) { + return i->second; + } else { + throw std::out_of_range("key not found"); + } + } + + void set(const KeyType& key, const MappedType& x) { + (*self)[key] = x; + } + + void del(const KeyType& key) throw (std::out_of_range) { + std::unordered_map::iterator i = self->find(key); + + if (i != self->end()) { + self->erase(i); + } else { + throw std::out_of_range("key not found"); + } + } + + bool has_key(const KeyType& key) { + std::unordered_map::iterator i = self->find(key); + return i != self->end(); + } + } +}; + +} // namespace std diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i new file mode 100644 index 000000000..a9fac0f82 --- /dev/null +++ b/Lib/java/std_unordered_set.i @@ -0,0 +1,47 @@ +/* ----------------------------------------------------------------------------- + * std_unordered_set.i + * + * SWIG typemaps for std::unordered_set + * ----------------------------------------------------------------------------- */ + +%include + +// ------------------------------------------------------------------------ +// std::unordered_set +// ------------------------------------------------------------------------ + +%{ +#include +%} + +namespace std { + +template +class unordered_set { + public: + unordered_set(); + unordered_set(const unordered_set&); + + unsigned int size() const; + bool empty() const; + void clear(); + + %extend { + // Returns whether item was inserted. + bool insert(const KeyType& key) { + return self->insert(key).second; + } + + // Returns whether set contains key. + bool has(const KeyType& key) { + return (self->count(key) > 0); + } + + // Returns whether the item was erased. + bool erase(const KeyType& key) { + return (self->erase(key) > 0); + } + } +}; + +} // namespace std \ No newline at end of file From 4fe9406fae90fd01463d3199184fd53112a3f0e3 Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Sat, 24 Nov 2018 10:00:23 -0500 Subject: [PATCH 02/26] Add test cases to C++11 list --- Examples/test-suite/java/Makefile.in | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Examples/test-suite/java/Makefile.in b/Examples/test-suite/java/Makefile.in index acb0ef2e3..b5b1d65c7 100644 --- a/Examples/test-suite/java/Makefile.in +++ b/Examples/test-suite/java/Makefile.in @@ -46,8 +46,6 @@ CPP_TEST_CASES = \ li_std_list \ li_std_map \ li_std_set \ - li_std_unordered_map \ - li_std_unordered_set \ # li_boost_intrusive_ptr CPP11_TEST_CASES = \ @@ -56,6 +54,8 @@ CPP11_TEST_CASES = \ cpp11_shared_ptr_overload \ cpp11_shared_ptr_upcast \ cpp11_strongly_typed_enumerations_simple \ + li_std_unordered_map \ + li_std_unordered_set \ DOXYGEN_TEST_CASES := \ doxygen_parsing_enums_simple \ From b1697d7772e2b96367b0a73a756106ed96295190 Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Wed, 28 Nov 2018 16:51:53 -0500 Subject: [PATCH 03/26] Move unordered containers under cpp11_ prefix --- ...{li_std_unordered_map.i => cpp11_li_std_unordered_map.i} | 3 +-- ...{li_std_unordered_set.i => cpp11_li_std_unordered_set.i} | 3 +-- Examples/test-suite/java/Makefile.in | 4 ++-- ...map_runme.java => cpp11_li_std_unordered_map_runme.java} | 6 +++--- ...set_runme.java => cpp11_li_std_unordered_set_runme.java} | 6 +++--- 5 files changed, 10 insertions(+), 12 deletions(-) rename Examples/test-suite/{li_std_unordered_map.i => cpp11_li_std_unordered_map.i} (87%) rename Examples/test-suite/{li_std_unordered_set.i => cpp11_li_std_unordered_set.i} (82%) rename Examples/test-suite/java/{li_std_unordered_map_runme.java => cpp11_li_std_unordered_map_runme.java} (95%) rename Examples/test-suite/java/{li_std_unordered_set_runme.java => cpp11_li_std_unordered_set_runme.java} (91%) diff --git a/Examples/test-suite/li_std_unordered_map.i b/Examples/test-suite/cpp11_li_std_unordered_map.i similarity index 87% rename from Examples/test-suite/li_std_unordered_map.i rename to Examples/test-suite/cpp11_li_std_unordered_map.i index a6869cc0b..5f40e76fd 100644 --- a/Examples/test-suite/li_std_unordered_map.i +++ b/Examples/test-suite/cpp11_li_std_unordered_map.i @@ -2,11 +2,10 @@ * A test of unordered_map containers. */ -%module li_std_unordered_map +%module cpp11_li_std_unordered_map %include %include %template(IntIntUnorderedMap) std::unordered_map; %template(StringIntUnorderedMap) std::unordered_map; - diff --git a/Examples/test-suite/li_std_unordered_set.i b/Examples/test-suite/cpp11_li_std_unordered_set.i similarity index 82% rename from Examples/test-suite/li_std_unordered_set.i rename to Examples/test-suite/cpp11_li_std_unordered_set.i index a051e9389..e9711ce60 100644 --- a/Examples/test-suite/li_std_unordered_set.i +++ b/Examples/test-suite/cpp11_li_std_unordered_set.i @@ -2,10 +2,9 @@ * A test of unordered_set containers. */ -%module li_std_unordered_set +%module cpp11_li_std_unordered_set %include %include %template(StringUnorderedSet) std::unordered_set; - diff --git a/Examples/test-suite/java/Makefile.in b/Examples/test-suite/java/Makefile.in index b5b1d65c7..3323f8a9c 100644 --- a/Examples/test-suite/java/Makefile.in +++ b/Examples/test-suite/java/Makefile.in @@ -54,8 +54,8 @@ CPP11_TEST_CASES = \ cpp11_shared_ptr_overload \ cpp11_shared_ptr_upcast \ cpp11_strongly_typed_enumerations_simple \ - li_std_unordered_map \ - li_std_unordered_set \ + cpp11_li_std_unordered_map \ + cpp11_li_std_unordered_set \ DOXYGEN_TEST_CASES := \ doxygen_parsing_enums_simple \ diff --git a/Examples/test-suite/java/li_std_unordered_map_runme.java b/Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java similarity index 95% rename from Examples/test-suite/java/li_std_unordered_map_runme.java rename to Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java index 8ab6f23e4..f216a0131 100644 --- a/Examples/test-suite/java/li_std_unordered_map_runme.java +++ b/Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java @@ -1,10 +1,10 @@ -import li_std_unordered_map.*; +import cpp11_li_std_unordered_map.*; -public class li_std_unordered_map_runme { +public class cpp11_li_std_unordered_map_runme { static { try { - System.loadLibrary("li_std_unordered_map"); + System.loadLibrary("cpp11_li_std_unordered_map"); } catch (UnsatisfiedLinkError e) { System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); System.exit(1); diff --git a/Examples/test-suite/java/li_std_unordered_set_runme.java b/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java similarity index 91% rename from Examples/test-suite/java/li_std_unordered_set_runme.java rename to Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java index ce94f8fe4..ce33780f0 100644 --- a/Examples/test-suite/java/li_std_unordered_set_runme.java +++ b/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java @@ -1,10 +1,10 @@ -import li_std_unordered_set.*; +import cpp11_li_std_unordered_set.*; -public class li_std_unordered_set_runme { +public class cpp11_li_std_unordered_set_runme { static { try { - System.loadLibrary("li_std_unordered_set"); + System.loadLibrary("cpp11_li_std_unordered_set"); } catch (UnsatisfiedLinkError e) { System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); System.exit(1); From 6ccc940a143406588f29d896fd0eb2f8113e0195 Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Fri, 30 Nov 2018 18:21:02 -0500 Subject: [PATCH 04/26] Add set/unordered_set that extend AbstractSet --- .../cpp11_li_std_unordered_set_runme.java | 72 ++++++--- .../test-suite/java/li_std_set_runme.java | 72 ++++++--- Lib/java/std_set.i | 150 +++++++++++++++++- Lib/java/std_unordered_set.i | 150 +++++++++++++++++- 4 files changed, 400 insertions(+), 44 deletions(-) diff --git a/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java b/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java index ce33780f0..15f6eba0a 100644 --- a/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java +++ b/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java @@ -11,30 +11,66 @@ public class cpp11_li_std_unordered_set_runme { } } + public static void failTest(int testNum) throws Throwable { + throw new RuntimeException("Test failed: " + testNum); + } + + public static void checkThat(boolean mustBeTrue, int testNum) throws Throwable { + if (!mustBeTrue) failTest(testNum); + } + public static void main(String argv[]) throws Throwable { - StringUnorderedSet ss = new StringUnorderedSet(); + java.util.AbstractSet ss = new StringUnorderedSet(); - if (!ss.empty()) throw new RuntimeException("Test (1) failed"); - if (ss.size() != 0) throw new RuntimeException("Test (2) failed"); - if (ss.has("key")) throw new RuntimeException("Test (3) failed"); - if (ss.erase("key")) throw new RuntimeException("Test (4) failed"); + checkThat(ss.isEmpty(), 1); + checkThat(!ss.contains("key"), 2); + checkThat(!ss.remove("key"), 3); - if (!ss.insert("key")) throw new RuntimeException("Test (5) failed"); - if (ss.insert("key")) throw new RuntimeException("Test (6) failed"); - if (!ss.has("key")) throw new RuntimeException("Test (7) failed"); + checkThat(ss.add("key"), 4); + checkThat(!ss.add("key"), 5); + checkThat(ss.contains("key"), 6); + checkThat(ss.remove("key"), 7); + checkThat(ss.isEmpty(), 8); + checkThat(ss.size() == 0, 9); - if (!ss.erase("key")) throw new RuntimeException("Test (8) failed"); - if (!ss.empty()) throw new RuntimeException("Test (9) failed"); - if (ss.size() != 0) throw new RuntimeException("Test (10) failed"); - - if (!ss.insert("key1")) throw new RuntimeException("Test (11) failed"); - if (!ss.insert("key2")) throw new RuntimeException("Test (12) failed"); - if (!ss.insert("key3")) throw new RuntimeException("Test (13) failed"); - if (ss.size() != 3) throw new RuntimeException("Test (14) failed"); + checkThat(ss.add("key1"), 10); + checkThat(ss.add("key2"), 11); + checkThat(ss.add("key3"), 12); + checkThat(ss.size() == 3, 13); ss.clear(); - if (!ss.empty()) throw new RuntimeException("Test (15) failed"); - if (ss.size() != 0) throw new RuntimeException("Test (16) failed"); + checkThat(ss.isEmpty(), 14); + checkThat(ss.size() == 0, 15); + + checkThat(ss.addAll(java.util.Arrays.asList("one", "two", "three")), 16); + checkThat(ss.size() == 3, 17); + checkThat(ss.contains("one"), 18); + checkThat(!ss.contains("four"), 19); + + checkThat(ss.containsAll(java.util.Arrays.asList("one", "two", "three")), 20); + checkThat(ss.containsAll(java.util.Arrays.asList("one", "two")), 21); + checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "four")), 22); + checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "three", "four")), 23); + + checkThat(!ss.addAll(java.util.Arrays.asList("one", "two", "three")), 24); + + java.util.Set found = new java.util.HashSet(); + java.util.Iterator itr = ss.iterator(); + while (itr.hasNext()) { + found.add(itr.next()); + } + + checkThat(ss.containsAll(found), 25); + checkThat(found.containsAll(ss), 26); + + java.util.AbstractSet ss2 = new StringUnorderedSet(ss); + checkThat(ss2.containsAll(ss), 27); + checkThat(ss.containsAll(ss2), 28); + + checkThat(!ss.removeAll(java.util.Arrays.asList("five", "four")), 29); + checkThat(ss.removeAll(found), 30); + checkThat(ss.isEmpty(), 31); + checkThat(ss.size() == 0, 32); } } diff --git a/Examples/test-suite/java/li_std_set_runme.java b/Examples/test-suite/java/li_std_set_runme.java index 61edd93dc..7bbd3fced 100644 --- a/Examples/test-suite/java/li_std_set_runme.java +++ b/Examples/test-suite/java/li_std_set_runme.java @@ -11,30 +11,66 @@ public class li_std_set_runme { } } + public static void failTest(int testNum) throws Throwable { + throw new RuntimeException("Test failed: " + testNum); + } + + public static void checkThat(boolean mustBeTrue, int testNum) throws Throwable { + if (!mustBeTrue) failTest(testNum); + } + public static void main(String argv[]) throws Throwable { - StringSet ss = new StringSet(); + java.util.AbstractSet ss = new StringSet(); - if (!ss.empty()) throw new RuntimeException("Test (1) failed"); - if (ss.size() != 0) throw new RuntimeException("Test (2) failed"); - if (ss.has("key")) throw new RuntimeException("Test (3) failed"); - if (ss.erase("key")) throw new RuntimeException("Test (4) failed"); + checkThat(ss.isEmpty(), 1); + checkThat(!ss.contains("key"), 2); + checkThat(!ss.remove("key"), 3); - if (!ss.insert("key")) throw new RuntimeException("Test (5) failed"); - if (ss.insert("key")) throw new RuntimeException("Test (6) failed"); - if (!ss.has("key")) throw new RuntimeException("Test (7) failed"); + checkThat(ss.add("key"), 4); + checkThat(!ss.add("key"), 5); + checkThat(ss.contains("key"), 6); + checkThat(ss.remove("key"), 7); + checkThat(ss.isEmpty(), 8); + checkThat(ss.size() == 0, 9); - if (!ss.erase("key")) throw new RuntimeException("Test (8) failed"); - if (!ss.empty()) throw new RuntimeException("Test (9) failed"); - if (ss.size() != 0) throw new RuntimeException("Test (10) failed"); - - if (!ss.insert("key1")) throw new RuntimeException("Test (11) failed"); - if (!ss.insert("key2")) throw new RuntimeException("Test (12) failed"); - if (!ss.insert("key3")) throw new RuntimeException("Test (13) failed"); - if (ss.size() != 3) throw new RuntimeException("Test (14) failed"); + checkThat(ss.add("key1"), 10); + checkThat(ss.add("key2"), 11); + checkThat(ss.add("key3"), 12); + checkThat(ss.size() == 3, 13); ss.clear(); - if (!ss.empty()) throw new RuntimeException("Test (15) failed"); - if (ss.size() != 0) throw new RuntimeException("Test (16) failed"); + checkThat(ss.isEmpty(), 14); + checkThat(ss.size() == 0, 15); + + checkThat(ss.addAll(java.util.Arrays.asList("one", "two", "three")), 16); + checkThat(ss.size() == 3, 17); + checkThat(ss.contains("one"), 18); + checkThat(!ss.contains("four"), 19); + + checkThat(ss.containsAll(java.util.Arrays.asList("one", "two", "three")), 20); + checkThat(ss.containsAll(java.util.Arrays.asList("one", "two")), 21); + checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "four")), 22); + checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "three", "four")), 23); + + checkThat(!ss.addAll(java.util.Arrays.asList("one", "two", "three")), 24); + + java.util.Set found = new java.util.HashSet(); + java.util.Iterator itr = ss.iterator(); + while (itr.hasNext()) { + found.add(itr.next()); + } + + checkThat(ss.containsAll(found), 25); + checkThat(found.containsAll(ss), 26); + + java.util.AbstractSet ss2 = new StringSet(ss); + checkThat(ss2.containsAll(ss), 27); + checkThat(ss.containsAll(ss2), 28); + + checkThat(!ss.removeAll(java.util.Arrays.asList("five", "four")), 29); + checkThat(ss.removeAll(found), 30); + checkThat(ss.isEmpty(), 31); + checkThat(ss.size() == 0, 32); } } diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i index 8c4bb7f17..57613f322 100644 --- a/Lib/java/std_set.i +++ b/Lib/java/std_set.i @@ -2,6 +2,8 @@ * std_set.i * * SWIG typemaps for std::set + * The Java proxy class extends java.util.AbstractSet. The std::set + * container looks and feels much like a java.util.HashSet from Java. * ----------------------------------------------------------------------------- */ %include @@ -12,35 +14,175 @@ %{ #include +#include %} +%fragment("SWIG_SetSize", "header", fragment="SWIG_JavaIntFromSize_t") { + SWIGINTERN jint SWIG_SetSize(size_t size) { + jint sz = SWIG_JavaIntFromSize_t(size); + if (sz == -1) { + throw std::out_of_range("set size is too large to fit into a Java int"); + } + + return sz; + } +} + +%javamethodmodifiers std::set::sizeImpl "private"; +%javamethodmodifiers std::set::containsImpl "private"; +%javamethodmodifiers std::set::removeImpl "private"; +%javamethodmodifiers std::set::hasNextImpl "private"; +%javamethodmodifiers std::set::begin "private"; +%javamethodmodifiers std::set::end "private"; + +%rename(Iterator) std::set::iterator; +%nodefaultctor std::set::iterator; +%javamethodmodifiers std::set::iterator::incrementUnchecked "private"; +%javamethodmodifiers std::set::iterator::derefUnchecked "private"; +%javamethodmodifiers std::set::iterator::isNot "private"; + namespace std { template class set { + +%typemap(javabase) std::set "java.util.AbstractSet<$typemap(jboxtype, KeyType)>" +%proxycode %{ + public $javaclassname(java.util.Collection collection) { + this(); + addAll(collection); + } + + public int size() { + return sizeImpl(); + } + + public boolean addAll(java.util.Collection collection) { + boolean didAddElement = false; + for (Object object : collection) { + didAddElement |= add(($typemap(jboxtype, KeyType))object); + } + + return didAddElement; + } + + public java.util.Iterator<$typemap(jboxtype, KeyType)> iterator() { + return new java.util.Iterator<$typemap(jboxtype, KeyType)>() { + private Iterator curr; + private Iterator end; + + private java.util.Iterator<$typemap(jboxtype, KeyType)> init() { + curr = $javaclassname.this.begin(); + end = $javaclassname.this.end(); + return this; + } + + public $typemap(jboxtype, KeyType) next() { + if (!hasNext()) { + throw new java.util.NoSuchElementException(); + } + + // Save the current position, increment it, + // then return the value at the position before the increment. + final $typemap(jboxtype, KeyType) currValue = curr.derefUnchecked(); + curr.incrementUnchecked(); + return currValue; + } + + public boolean hasNext() { + return curr.isNot(end); + } + }.init(); + } + + public boolean containsAll(java.util.Collection collection) { + for (Object object : collection) { + if (!contains(object)) { + return false; + } + } + + return true; + } + + public boolean contains(Object object) { + if (!(object instanceof $typemap(jboxtype, KeyType))) { + return false; + } + + return containsImpl(($typemap(jboxtype, KeyType))object); + } + + public boolean removeAll(java.util.Collection collection) { + boolean didRemoveElement = false; + for (Object object : collection) { + didRemoveElement |= remove(object); + } + + return didRemoveElement; + } + + public boolean remove(Object object) { + if (!(object instanceof $typemap(jboxtype, KeyType))) { + return false; + } + + return removeImpl(($typemap(jboxtype, KeyType))object); + } +%} + public: + + struct iterator { + %extend { + void incrementUnchecked() { + ++(*$self); + } + + KeyType derefUnchecked() const { + return **$self; + } + + bool isNot(const iterator other) const { + return (*$self != other); + } + } + }; + set(); set(const set&); - unsigned int size() const; + %rename(isEmpty) empty; bool empty() const; void clear(); + iterator begin(); + iterator end(); %extend { + %fragment("SWIG_SetSize"); + // Returns whether item was inserted. - bool insert(const KeyType& key) { + bool add(const KeyType& key) { return self->insert(key).second; } // Returns whether set contains key. - bool has(const KeyType& key) { + bool containsImpl(const KeyType& key) { return (self->count(key) > 0); } // Returns whether the item was erased. - bool erase(const KeyType& key) { + bool removeImpl(const KeyType& key) { return (self->erase(key) > 0); } + + jint sizeImpl() const throw (std::out_of_range) { + return SWIG_SetSize(self->size()); + } + + bool hasNextImpl(const iterator& itr) const { + return (itr != $self->end()); + } } }; diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i index a9fac0f82..4074d8045 100644 --- a/Lib/java/std_unordered_set.i +++ b/Lib/java/std_unordered_set.i @@ -2,6 +2,8 @@ * std_unordered_set.i * * SWIG typemaps for std::unordered_set + * The Java proxy class extends java.util.AbstractSet. The std::unordered_set + * container looks and feels much like a java.util.HashSet from Java. * ----------------------------------------------------------------------------- */ %include @@ -12,35 +14,175 @@ %{ #include +#include %} +%fragment("SWIG_UnorderedSetSize", "header", fragment="SWIG_JavaIntFromSize_t") { + SWIGINTERN jint SWIG_UnorderedSetSize(size_t size) { + jint sz = SWIG_JavaIntFromSize_t(size); + if (sz == -1) { + throw std::out_of_range("unordered_set size is too large to fit into a Java int"); + } + + return sz; + } +} + +%javamethodmodifiers std::unordered_set::sizeImpl "private"; +%javamethodmodifiers std::unordered_set::containsImpl "private"; +%javamethodmodifiers std::unordered_set::removeImpl "private"; +%javamethodmodifiers std::unordered_set::hasNextImpl "private"; +%javamethodmodifiers std::unordered_set::begin "private"; +%javamethodmodifiers std::unordered_set::end "private"; + +%rename(Iterator) std::unordered_set::iterator; +%nodefaultctor std::unordered_set::iterator; +%javamethodmodifiers std::unordered_set::iterator::incrementUnchecked "private"; +%javamethodmodifiers std::unordered_set::iterator::derefUnchecked "private"; +%javamethodmodifiers std::unordered_set::iterator::isNot "private"; + namespace std { template class unordered_set { + +%typemap(javabase) std::unordered_set "java.util.AbstractSet<$typemap(jboxtype, KeyType)>" +%proxycode %{ + public $javaclassname(java.util.Collection collection) { + this(); + addAll(collection); + } + + public int size() { + return sizeImpl(); + } + + public boolean addAll(java.util.Collection collection) { + boolean didAddElement = false; + for (Object object : collection) { + didAddElement |= add(($typemap(jboxtype, KeyType))object); + } + + return didAddElement; + } + + public java.util.Iterator<$typemap(jboxtype, KeyType)> iterator() { + return new java.util.Iterator<$typemap(jboxtype, KeyType)>() { + private Iterator curr; + private Iterator end; + + private java.util.Iterator<$typemap(jboxtype, KeyType)> init() { + curr = $javaclassname.this.begin(); + end = $javaclassname.this.end(); + return this; + } + + public $typemap(jboxtype, KeyType) next() { + if (!hasNext()) { + throw new java.util.NoSuchElementException(); + } + + // Save the current position, increment it, + // then return the value at the position before the increment. + final $typemap(jboxtype, KeyType) currValue = curr.derefUnchecked(); + curr.incrementUnchecked(); + return currValue; + } + + public boolean hasNext() { + return curr.isNot(end); + } + }.init(); + } + + public boolean containsAll(java.util.Collection collection) { + for (Object object : collection) { + if (!contains(object)) { + return false; + } + } + + return true; + } + + public boolean contains(Object object) { + if (!(object instanceof $typemap(jboxtype, KeyType))) { + return false; + } + + return containsImpl(($typemap(jboxtype, KeyType))object); + } + + public boolean removeAll(java.util.Collection collection) { + boolean didRemoveElement = false; + for (Object object : collection) { + didRemoveElement |= remove(object); + } + + return didRemoveElement; + } + + public boolean remove(Object object) { + if (!(object instanceof $typemap(jboxtype, KeyType))) { + return false; + } + + return removeImpl(($typemap(jboxtype, KeyType))object); + } +%} + public: + + struct iterator { + %extend { + void incrementUnchecked() { + ++(*$self); + } + + KeyType derefUnchecked() const { + return **$self; + } + + bool isNot(const iterator other) const { + return (*$self != other); + } + } + }; + unordered_set(); unordered_set(const unordered_set&); - unsigned int size() const; + %rename(isEmpty) empty; bool empty() const; void clear(); + iterator begin(); + iterator end(); %extend { + %fragment("SWIG_UnorderedSetSize"); + // Returns whether item was inserted. - bool insert(const KeyType& key) { + bool add(const KeyType& key) { return self->insert(key).second; } // Returns whether set contains key. - bool has(const KeyType& key) { + bool containsImpl(const KeyType& key) { return (self->count(key) > 0); } // Returns whether the item was erased. - bool erase(const KeyType& key) { + bool removeImpl(const KeyType& key) { return (self->erase(key) > 0); } + + jint sizeImpl() const throw (std::out_of_range) { + return SWIG_UnorderedSetSize(self->size()); + } + + bool hasNextImpl(const iterator& itr) const { + return (itr != $self->end()); + } } }; From e6d86755137f40a6ec8e262a2a9a470554a0aac8 Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Tue, 4 Dec 2018 01:08:47 -0500 Subject: [PATCH 05/26] Mostly working for map --- .../test-suite/java/li_std_map_runme.java | 131 +++++++------- Lib/java/std_map.i | 166 +++++++++++++----- 2 files changed, 187 insertions(+), 110 deletions(-) diff --git a/Examples/test-suite/java/li_std_map_runme.java b/Examples/test-suite/java/li_std_map_runme.java index 3cc794ced..ed5b43a31 100644 --- a/Examples/test-suite/java/li_std_map_runme.java +++ b/Examples/test-suite/java/li_std_map_runme.java @@ -11,91 +11,92 @@ public class li_std_map_runme { } } + public static void failTest(int testNum) throws Throwable { + throw new RuntimeException("Test failed: " + testNum); + } + + public static void checkThat(boolean mustBeTrue, int testNum) throws Throwable { + if (!mustBeTrue) failTest(testNum); + } + public static void main(String argv[]) throws Throwable { - StringIntMap sim = new StringIntMap(); - IntIntMap iim = new IntIntMap(); + java.util.AbstractMap sim = new StringIntMap(); + java.util.AbstractMap iim = new IntIntMap(); - if (!sim.empty()) throw new RuntimeException("Test (1) failed"); - if (!iim.empty()) throw new RuntimeException("Test (2) failed"); + checkThat(sim.isEmpty(), 1); + checkThat(iim.isEmpty(), 2); + checkThat(sim.size() == 0, 3); + checkThat(iim.size() == 0, 4); - if (sim.size() != 0) throw new RuntimeException("Test (3) failed"); - if (iim.size() != 0) throw new RuntimeException("Test (4) failed"); + checkThat(sim.get("key") == null, 5); + checkThat(iim.get(1) == null, 6); - try { - sim.get("key"); - throw new RuntimeException("Test (5) failed"); - } catch (IndexOutOfBoundsException e) { - } + checkThat(!sim.containsKey("key"), 7); + checkThat(!iim.containsKey(1), 8); - try { - iim.get(1); - throw new RuntimeException("Test (6) failed"); - } catch (IndexOutOfBoundsException e) { - } + checkThat(sim.put("key", 2) == null, 9); + checkThat(iim.put(1, 2) == null, 10); - sim.set("key", 1); - iim.set(1, 1); + // if (sim.size() != 1) throw new RuntimeException("Test (7) failed"); + // if (iim.size() != 1) throw new RuntimeException("Test (8) failed"); - if (sim.size() != 1) throw new RuntimeException("Test (7) failed"); - if (iim.size() != 1) throw new RuntimeException("Test (8) failed"); + // sim.remove("key"); + // iim.remove(1); - sim.del("key"); - iim.del(1); + // if (sim.containsKey("key")) throw new RuntimeException("Test (9) failed"); + // if (iim.containsKey(1)) throw new RuntimeException("Test (10) failed"); - if (sim.has_key("key")) throw new RuntimeException("Test (9) failed"); - if (iim.has_key(1)) throw new RuntimeException("Test (10) failed"); + // if (!sim.isEmpty()) throw new RuntimeException("Test (11) failed"); + // if (!iim.isEmpty()) throw new RuntimeException("Test (12) failed"); + // if (sim.size() != 0) throw new RuntimeException("Test (13) failed"); + // if (iim.size() != 0) throw new RuntimeException("Test (14) failed"); - if (!sim.empty()) throw new RuntimeException("Test (11) failed"); - if (!iim.empty()) throw new RuntimeException("Test (12) failed"); - if (sim.size() != 0) throw new RuntimeException("Test (13) failed"); - if (iim.size() != 0) throw new RuntimeException("Test (14) failed"); + // try { + // sim.remove("key"); + // throw new RuntimeException("Test (15) failed"); + // } catch (IndexOutOfBoundsException e) { + // } - try { - sim.del("key"); - throw new RuntimeException("Test (15) failed"); - } catch (IndexOutOfBoundsException e) { - } + // try { + // iim.remove(1); + // throw new RuntimeException("Test (16) failed"); + // } catch (IndexOutOfBoundsException e) { + // } - try { - iim.del(1); - throw new RuntimeException("Test (16) failed"); - } catch (IndexOutOfBoundsException e) { - } + // sim.put("key", 1); + // iim.put(1, 1); - sim.set("key", 1); - iim.set(1, 1); + // if (sim.size() != 1) throw new RuntimeException("Test (17) failed"); + // if (iim.size() != 1) throw new RuntimeException("Test (18) failed"); - if (sim.size() != 1) throw new RuntimeException("Test (17) failed"); - if (iim.size() != 1) throw new RuntimeException("Test (18) failed"); + // sim.clear(); + // iim.clear(); - sim.clear(); - iim.clear(); + // if (sim.containsKey("key")) throw new RuntimeException("Test (19) failed"); + // if (iim.containsKey(1)) throw new RuntimeException("Test (20) failed"); - if (sim.has_key("key")) throw new RuntimeException("Test (19) failed"); - if (iim.has_key(1)) throw new RuntimeException("Test (20) failed"); + // if (!sim.isEmpty()) throw new RuntimeException("Test (21) failed"); + // if (!iim.isEmpty()) throw new RuntimeException("Test (22) failed"); + // if (sim.size() != 0) throw new RuntimeException("Test (23) failed"); + // if (iim.size() != 0) throw new RuntimeException("Test (24) failed"); - if (!sim.empty()) throw new RuntimeException("Test (21) failed"); - if (!iim.empty()) throw new RuntimeException("Test (22) failed"); - if (sim.size() != 0) throw new RuntimeException("Test (23) failed"); - if (iim.size() != 0) throw new RuntimeException("Test (24) failed"); + // sim.put("key", 1); + // sim.put("key2", 2); + // iim.put(1, 1); + // iim.put(2, 2); - sim.set("key", 1); - sim.set("key2", 2); - iim.set(1, 1); - iim.set(2, 2); + // if (sim.get("key") != 1) throw new RuntimeException("Test (25) failed"); + // if (sim.get("key2") != 2) throw new RuntimeException("Test (26) failed"); + // if (iim.get(1) != 1) throw new RuntimeException("Test (27) failed"); + // if (iim.get(2) != 2) throw new RuntimeException("Test (28) failed"); - if (sim.get("key") != 1) throw new RuntimeException("Test (25) failed"); - if (sim.get("key2") != 2) throw new RuntimeException("Test (26) failed"); - if (iim.get(1) != 1) throw new RuntimeException("Test (27) failed"); - if (iim.get(2) != 2) throw new RuntimeException("Test (28) failed"); + // sim.put("key", 3); + // iim.put(1, 3); - sim.set("key", 3); - iim.set(1, 3); - - if (sim.get("key") != 3) throw new RuntimeException("Test (29) failed"); - if (sim.get("key2") != 2) throw new RuntimeException("Test (30) failed"); - if (iim.get(1) != 3) throw new RuntimeException("Test (31) failed"); - if (iim.get(2) != 2) throw new RuntimeException("Test (32) failed"); + // if (sim.get("key") != 3) throw new RuntimeException("Test (29) failed"); + // if (sim.get("key2") != 2) throw new RuntimeException("Test (30) failed"); + // if (iim.get(1) != 3) throw new RuntimeException("Test (31) failed"); + // if (iim.get(2) != 2) throw new RuntimeException("Test (32) failed"); } } diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index 75d523cec..4169a18b4 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -2,9 +2,12 @@ * std_map.i * * SWIG typemaps for std::map + * The Java proxy class extends java.util.AbstractMap. The std::map + * container looks and feels much like a java.util.HashMap from Java. * ----------------------------------------------------------------------------- */ %include +%include // ------------------------------------------------------------------------ // std::map @@ -12,60 +15,133 @@ %{ #include -#include #include %} +%fragment("SWIG_MapSize", "header", fragment="SWIG_JavaIntFromSize_t") { + SWIGINTERN jint SWIG_MapSize(size_t size) { + jint sz = SWIG_JavaIntFromSize_t(size); + if (sz == -1) { + throw std::out_of_range("map size is too large to fit into a Java int"); + } + + return sz; + } +} + +%javamethodmodifiers std::map::sizeImpl "private"; +%javamethodmodifiers std::map::containsImpl "private"; +%javamethodmodifiers std::map::getImpl "private"; +%javamethodmodifiers std::map::putImpl "private"; +%javamethodmodifiers std::map::removeImpl "private"; + namespace std { - template > class map { - public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef K key_type; - typedef T mapped_type; - map(); - map(const map< K, T, C > &); +template > class map { - unsigned int size() const; - bool empty() const; - void clear(); - %extend { - const T& get(const K& key) throw (std::out_of_range) { - std::map< K, T, C >::iterator i = self->find(key); - if (i != self->end()) - return i->second; - else - throw std::out_of_range("key not found"); - } - void set(const K& key, const T& x) { - (*self)[key] = x; - } - void del(const K& key) throw (std::out_of_range) { - std::map< K, T, C >::iterator i = self->find(key); - if (i != self->end()) - self->erase(i); - else - throw std::out_of_range("key not found"); - } - bool has_key(const K& key) { - std::map< K, T, C >::iterator i = self->find(key); - return i != self->end(); +%typemap(javabase) std::map + "java.util.AbstractMap<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)>" + +%proxycode %{ + + public int size() { + return sizeImpl(); + } + + public boolean containsKey(Object object) { + if (!(object instanceof $typemap(jboxtype, KeyType))) { + return false; + } + + return containsImpl(($typemap(jboxtype, KeyType))object); + } + + public $typemap(jboxtype, ValueType) get(Object object) { + if (!(object instanceof $typemap(jboxtype, KeyType))) { + return null; + } + + try { + getImpl(($typemap(jboxtype, KeyType)) object); + } catch (IndexOutOfBoundsException e) {} + + return null; + } + + public $typemap(jboxtype, ValueType) put($typemap(jboxtype, KeyType) key, + $typemap(jboxtype, ValueType) value) { + try { + $typemap(jboxtype, ValueType) oldValue = putImpl(key, value); + return oldValue; + } catch (IndexOutOfBoundsException e) {} + + return null; + } + + public $typemap(jboxtype, ValueType) remove($typemap(jboxtype, KeyType) key) { + try { + $typemap(jboxtype, ValueType) oldValue = removeImpl(key); + return oldValue; + } catch (IndexOutOfBoundsException e) {} + + return null; + } + + public java.util.Set> entrySet() { + throw new RuntimeException("Stub"); + } +%} + + public: + map(); + map(const map&); + + %rename(isEmpty) empty; + bool empty() const; + void clear(); + %extend { + %fragment("SWIG_MapSize"); + + jint sizeImpl() const throw (std::out_of_range) { + return SWIG_MapSize(self->size()); + } + + bool containsImpl(const KeyType& key) { + return (self->count(key) > 0); + } + + const ValueType& getImpl(const KeyType& key) throw (std::out_of_range) { + std::map::iterator itr = self->find(key); + if (itr != self->end()) { + return itr->second; + } else { + throw std::out_of_range("map::get() - key not found"); } } - }; -// Legacy macros (deprecated) -%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO) -#warning "specialize_std_map_on_key ignored - macro is deprecated and no longer necessary" -%enddef + ValueType putImpl(const KeyType& key, const ValueType& value) { + std::map::iterator itr = self->find(key); + if (itr != self->end()) { + ValueType oldValue = itr->second; + itr->second = value; + return oldValue; + } else { + (*self)[key] = value; + throw std::out_of_range("map::put() - no existing value for key"); + } + } -%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO) -#warning "specialize_std_map_on_value ignored - macro is deprecated and no longer necessary" -%enddef - -%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO) -#warning "specialize_std_map_on_both ignored - macro is deprecated and no longer necessary" -%enddef + ValueType removeImpl(const KeyType& key) throw (std::out_of_range) { + std::map::iterator itr = self->find(key); + if (itr != self->end()) { + ValueType oldValue = itr->second; + self->erase(itr); + return oldValue; + } else { + throw std::out_of_range("map::remove() - key not found"); + } + } + } +}; } From 573ddb061e86541326ef1ff3256af65ff70c7afe Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Thu, 27 Dec 2018 01:11:54 -0500 Subject: [PATCH 06/26] Maps both working as java.util impls --- .../cpp11_li_std_unordered_map_runme.java | 149 +++++++------ .../cpp11_li_std_unordered_set_runme.java | 75 ++++--- .../test-suite/java/li_std_map_runme.java | 144 +++++++------ .../test-suite/java/li_std_set_runme.java | 75 ++++--- Lib/java/std_map.i | 158 +++++++++----- Lib/java/std_unordered_map.i | 198 +++++++++++++++--- 6 files changed, 514 insertions(+), 285 deletions(-) diff --git a/Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java b/Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java index f216a0131..bb85eeadd 100644 --- a/Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java +++ b/Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java @@ -11,91 +11,112 @@ public class cpp11_li_std_unordered_map_runme { } } + public static void checkThat(boolean mustBeTrue) throws Throwable { + if (!mustBeTrue) { + // Index [2], since this function is one hop away from main, and [1] is the current method. + throw new RuntimeException("Test failed at line number " + Thread.currentThread().getStackTrace()[2].getLineNumber()); + } + } + public static void main(String argv[]) throws Throwable { - StringIntUnorderedMap sim = new StringIntUnorderedMap(); - IntIntUnorderedMap iim = new IntIntUnorderedMap(); + java.util.AbstractMap sim = new StringIntUnorderedMap(); + java.util.AbstractMap iim = new IntIntUnorderedMap(); - if (!sim.empty()) throw new RuntimeException("Test (1) failed"); - if (!iim.empty()) throw new RuntimeException("Test (2) failed"); + checkThat(sim.isEmpty()); + checkThat(iim.isEmpty()); + checkThat(sim.size() == 0); + checkThat(iim.size() == 0); - if (sim.size() != 0) throw new RuntimeException("Test (3) failed"); - if (iim.size() != 0) throw new RuntimeException("Test (4) failed"); + checkThat(sim.get("key") == null); + checkThat(iim.get(1) == null); - try { - sim.get("key"); - throw new RuntimeException("Test (5) failed"); - } catch (IndexOutOfBoundsException e) { - } + checkThat(!sim.containsKey("key")); + checkThat(!iim.containsKey(1)); - try { - iim.get(1); - throw new RuntimeException("Test (6) failed"); - } catch (IndexOutOfBoundsException e) { - } + checkThat(sim.put("key", 2) == null); + checkThat(iim.put(1, 2) == null); - sim.set("key", 1); - iim.set(1, 1); + checkThat(sim.size() == 1); + checkThat(iim.size() == 1); + checkThat(!sim.isEmpty()); + checkThat(!iim.isEmpty()); - if (sim.size() != 1) throw new RuntimeException("Test (7) failed"); - if (iim.size() != 1) throw new RuntimeException("Test (8) failed"); + checkThat(sim.get("key") == 2); + checkThat(iim.get(1) == 2); - sim.del("key"); - iim.del(1); + checkThat(sim.remove("key") == 2); + checkThat(iim.remove(1) == 2); - if (sim.has_key("key")) throw new RuntimeException("Test (9) failed"); - if (iim.has_key(1)) throw new RuntimeException("Test (10) failed"); + checkThat(sim.isEmpty()); + checkThat(iim.isEmpty()); + checkThat(sim.size() == 0); + checkThat(iim.size() == 0); - if (!sim.empty()) throw new RuntimeException("Test (11) failed"); - if (!iim.empty()) throw new RuntimeException("Test (12) failed"); - if (sim.size() != 0) throw new RuntimeException("Test (13) failed"); - if (iim.size() != 0) throw new RuntimeException("Test (14) failed"); + checkThat(sim.get("key") == null); + checkThat(iim.get(1) == null); - try { - sim.del("key"); - throw new RuntimeException("Test (15) failed"); - } catch (IndexOutOfBoundsException e) { - } + checkThat(sim.remove("key") == null); + checkThat(iim.remove(1) == null); - try { - iim.del(1); - throw new RuntimeException("Test (16) failed"); - } catch (IndexOutOfBoundsException e) { - } - - sim.set("key", 1); - iim.set(1, 1); - - if (sim.size() != 1) throw new RuntimeException("Test (17) failed"); - if (iim.size() != 1) throw new RuntimeException("Test (18) failed"); + checkThat(sim.put("key", 2) == null); + checkThat(iim.put(1, 2) == null); sim.clear(); iim.clear(); + checkThat(sim.isEmpty()); + checkThat(iim.isEmpty()); - if (sim.has_key("key")) throw new RuntimeException("Test (19) failed"); - if (iim.has_key(1)) throw new RuntimeException("Test (20) failed"); + checkThat(sim.put("key1", 1) == null); + checkThat(iim.put(1, 1) == null); + checkThat(sim.put("key2", 2) == null); + checkThat(iim.put(2, 2) == null); - if (!sim.empty()) throw new RuntimeException("Test (21) failed"); - if (!iim.empty()) throw new RuntimeException("Test (22) failed"); - if (sim.size() != 0) throw new RuntimeException("Test (23) failed"); - if (iim.size() != 0) throw new RuntimeException("Test (24) failed"); + checkThat(sim.size() == 2); + checkThat(iim.size() == 2); + checkThat(sim.get("key1") == 1); + checkThat(iim.get(1) == 1); + checkThat(sim.get("key2") == 2); + checkThat(iim.get(2) == 2); - sim.set("key", 1); - sim.set("key2", 2); - iim.set(1, 1); - iim.set(2, 2); + checkThat(sim.put("key1", 3) == 1); + checkThat(iim.put(1, 3) == 1); - if (sim.get("key") != 1) throw new RuntimeException("Test (25) failed"); - if (sim.get("key2") != 2) throw new RuntimeException("Test (26) failed"); - if (iim.get(1) != 1) throw new RuntimeException("Test (27) failed"); - if (iim.get(2) != 2) throw new RuntimeException("Test (28) failed"); + checkThat(sim.size() == 2); + checkThat(iim.size() == 2); + checkThat(sim.get("key1") == 3); + checkThat(iim.get(1) == 3); - sim.set("key", 3); - iim.set(1, 3); + java.util.Set> sim_es = sim.entrySet(); + java.util.Map sim_default = new java.util.HashMap(); + sim_default.put("key1", 3); + sim_default.put("key2", 2); + java.util.Set> sim_es_default = sim_default.entrySet(); + checkThat(sim_es.size() == sim_es_default.size()); + for (java.util.Map.Entry entry : sim_es) { + checkThat(sim_es_default.contains(entry)); + checkThat(sim_default.containsKey(entry.getKey())); + checkThat(sim_default.containsValue(entry.getValue())); - if (sim.get("key") != 3) throw new RuntimeException("Test (29) failed"); - if (sim.get("key2") != 2) throw new RuntimeException("Test (30) failed"); - if (iim.get(1) != 3) throw new RuntimeException("Test (31) failed"); - if (iim.get(2) != 2) throw new RuntimeException("Test (32) failed"); + Integer oldValue = entry.getValue(); + entry.setValue(oldValue + 1); + checkThat(sim.get(entry.getKey()) == (oldValue + 1)); + } + + java.util.Set> iim_es = iim.entrySet(); + java.util.Map iim_default = new java.util.HashMap(); + iim_default.put(1, 3); + iim_default.put(2, 2); + java.util.Set> iim_es_default = iim_default.entrySet(); + checkThat(iim_es.size() == iim_es_default.size()); + for (java.util.Map.Entry entry : iim_es) { + checkThat(iim_es_default.contains(entry)); + checkThat(iim_default.containsKey(entry.getKey())); + checkThat(iim_default.containsValue(entry.getValue())); + + Integer oldValue = entry.getValue(); + entry.setValue(oldValue + 1); + checkThat(iim.get(entry.getKey()) == (oldValue + 1)); + } } } diff --git a/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java b/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java index 15f6eba0a..dddf00307 100644 --- a/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java +++ b/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java @@ -11,49 +11,48 @@ public class cpp11_li_std_unordered_set_runme { } } - public static void failTest(int testNum) throws Throwable { - throw new RuntimeException("Test failed: " + testNum); - } - - public static void checkThat(boolean mustBeTrue, int testNum) throws Throwable { - if (!mustBeTrue) failTest(testNum); + public static void checkThat(boolean mustBeTrue) throws Throwable { + if (!mustBeTrue) { + // Index [2], since this function is one hop away from main, and [1] is the current method. + throw new RuntimeException("Test failed at line number " + Thread.currentThread().getStackTrace()[2].getLineNumber()); + } } public static void main(String argv[]) throws Throwable { java.util.AbstractSet ss = new StringUnorderedSet(); - checkThat(ss.isEmpty(), 1); - checkThat(!ss.contains("key"), 2); - checkThat(!ss.remove("key"), 3); + checkThat(ss.isEmpty()); + checkThat(!ss.contains("key")); + checkThat(!ss.remove("key")); - checkThat(ss.add("key"), 4); - checkThat(!ss.add("key"), 5); - checkThat(ss.contains("key"), 6); - checkThat(ss.remove("key"), 7); - checkThat(ss.isEmpty(), 8); - checkThat(ss.size() == 0, 9); + checkThat(ss.add("key")); + checkThat(!ss.add("key")); + checkThat(ss.contains("key")); + checkThat(ss.remove("key")); + checkThat(ss.isEmpty()); + checkThat(ss.size() == 0); - checkThat(ss.add("key1"), 10); - checkThat(ss.add("key2"), 11); - checkThat(ss.add("key3"), 12); - checkThat(ss.size() == 3, 13); + checkThat(ss.add("key1")); + checkThat(ss.add("key2")); + checkThat(ss.add("key3")); + checkThat(ss.size() == 3); ss.clear(); - checkThat(ss.isEmpty(), 14); - checkThat(ss.size() == 0, 15); + checkThat(ss.isEmpty()); + checkThat(ss.size() == 0); - checkThat(ss.addAll(java.util.Arrays.asList("one", "two", "three")), 16); - checkThat(ss.size() == 3, 17); - checkThat(ss.contains("one"), 18); - checkThat(!ss.contains("four"), 19); + checkThat(ss.addAll(java.util.Arrays.asList("one", "two", "three"))); + checkThat(ss.size() == 3); + checkThat(ss.contains("one")); + checkThat(!ss.contains("four")); - checkThat(ss.containsAll(java.util.Arrays.asList("one", "two", "three")), 20); - checkThat(ss.containsAll(java.util.Arrays.asList("one", "two")), 21); - checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "four")), 22); - checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "three", "four")), 23); + checkThat(ss.containsAll(java.util.Arrays.asList("one", "two", "three"))); + checkThat(ss.containsAll(java.util.Arrays.asList("one", "two"))); + checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "four"))); + checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "three", "four"))); - checkThat(!ss.addAll(java.util.Arrays.asList("one", "two", "three")), 24); + checkThat(!ss.addAll(java.util.Arrays.asList("one", "two", "three"))); java.util.Set found = new java.util.HashSet(); java.util.Iterator itr = ss.iterator(); @@ -61,16 +60,16 @@ public class cpp11_li_std_unordered_set_runme { found.add(itr.next()); } - checkThat(ss.containsAll(found), 25); - checkThat(found.containsAll(ss), 26); + checkThat(ss.containsAll(found)); + checkThat(found.containsAll(ss)); java.util.AbstractSet ss2 = new StringUnorderedSet(ss); - checkThat(ss2.containsAll(ss), 27); - checkThat(ss.containsAll(ss2), 28); + checkThat(ss2.containsAll(ss)); + checkThat(ss.containsAll(ss2)); - checkThat(!ss.removeAll(java.util.Arrays.asList("five", "four")), 29); - checkThat(ss.removeAll(found), 30); - checkThat(ss.isEmpty(), 31); - checkThat(ss.size() == 0, 32); + checkThat(!ss.removeAll(java.util.Arrays.asList("five", "four"))); + checkThat(ss.removeAll(found)); + checkThat(ss.isEmpty()); + checkThat(ss.size() == 0); } } diff --git a/Examples/test-suite/java/li_std_map_runme.java b/Examples/test-suite/java/li_std_map_runme.java index ed5b43a31..7ad4370cc 100644 --- a/Examples/test-suite/java/li_std_map_runme.java +++ b/Examples/test-suite/java/li_std_map_runme.java @@ -11,12 +11,11 @@ public class li_std_map_runme { } } - public static void failTest(int testNum) throws Throwable { - throw new RuntimeException("Test failed: " + testNum); - } - - public static void checkThat(boolean mustBeTrue, int testNum) throws Throwable { - if (!mustBeTrue) failTest(testNum); + public static void checkThat(boolean mustBeTrue) throws Throwable { + if (!mustBeTrue) { + // Index [2], since this function is one hop away from main, and [1] is the current method. + throw new RuntimeException("Test failed at line number " + Thread.currentThread().getStackTrace()[2].getLineNumber()); + } } public static void main(String argv[]) throws Throwable @@ -24,79 +23,100 @@ public class li_std_map_runme { java.util.AbstractMap sim = new StringIntMap(); java.util.AbstractMap iim = new IntIntMap(); - checkThat(sim.isEmpty(), 1); - checkThat(iim.isEmpty(), 2); - checkThat(sim.size() == 0, 3); - checkThat(iim.size() == 0, 4); + checkThat(sim.isEmpty()); + checkThat(iim.isEmpty()); + checkThat(sim.size() == 0); + checkThat(iim.size() == 0); - checkThat(sim.get("key") == null, 5); - checkThat(iim.get(1) == null, 6); + checkThat(sim.get("key") == null); + checkThat(iim.get(1) == null); - checkThat(!sim.containsKey("key"), 7); - checkThat(!iim.containsKey(1), 8); + checkThat(!sim.containsKey("key")); + checkThat(!iim.containsKey(1)); - checkThat(sim.put("key", 2) == null, 9); - checkThat(iim.put(1, 2) == null, 10); + checkThat(sim.put("key", 2) == null); + checkThat(iim.put(1, 2) == null); - // if (sim.size() != 1) throw new RuntimeException("Test (7) failed"); - // if (iim.size() != 1) throw new RuntimeException("Test (8) failed"); + checkThat(sim.size() == 1); + checkThat(iim.size() == 1); + checkThat(!sim.isEmpty()); + checkThat(!iim.isEmpty()); - // sim.remove("key"); - // iim.remove(1); + checkThat(sim.get("key") == 2); + checkThat(iim.get(1) == 2); - // if (sim.containsKey("key")) throw new RuntimeException("Test (9) failed"); - // if (iim.containsKey(1)) throw new RuntimeException("Test (10) failed"); + checkThat(sim.remove("key") == 2); + checkThat(iim.remove(1) == 2); - // if (!sim.isEmpty()) throw new RuntimeException("Test (11) failed"); - // if (!iim.isEmpty()) throw new RuntimeException("Test (12) failed"); - // if (sim.size() != 0) throw new RuntimeException("Test (13) failed"); - // if (iim.size() != 0) throw new RuntimeException("Test (14) failed"); + checkThat(sim.isEmpty()); + checkThat(iim.isEmpty()); + checkThat(sim.size() == 0); + checkThat(iim.size() == 0); - // try { - // sim.remove("key"); - // throw new RuntimeException("Test (15) failed"); - // } catch (IndexOutOfBoundsException e) { - // } + checkThat(sim.get("key") == null); + checkThat(iim.get(1) == null); - // try { - // iim.remove(1); - // throw new RuntimeException("Test (16) failed"); - // } catch (IndexOutOfBoundsException e) { - // } + checkThat(sim.remove("key") == null); + checkThat(iim.remove(1) == null); - // sim.put("key", 1); - // iim.put(1, 1); + checkThat(sim.put("key", 2) == null); + checkThat(iim.put(1, 2) == null); - // if (sim.size() != 1) throw new RuntimeException("Test (17) failed"); - // if (iim.size() != 1) throw new RuntimeException("Test (18) failed"); + sim.clear(); + iim.clear(); + checkThat(sim.isEmpty()); + checkThat(iim.isEmpty()); - // sim.clear(); - // iim.clear(); + checkThat(sim.put("key1", 1) == null); + checkThat(iim.put(1, 1) == null); + checkThat(sim.put("key2", 2) == null); + checkThat(iim.put(2, 2) == null); - // if (sim.containsKey("key")) throw new RuntimeException("Test (19) failed"); - // if (iim.containsKey(1)) throw new RuntimeException("Test (20) failed"); + checkThat(sim.size() == 2); + checkThat(iim.size() == 2); + checkThat(sim.get("key1") == 1); + checkThat(iim.get(1) == 1); + checkThat(sim.get("key2") == 2); + checkThat(iim.get(2) == 2); - // if (!sim.isEmpty()) throw new RuntimeException("Test (21) failed"); - // if (!iim.isEmpty()) throw new RuntimeException("Test (22) failed"); - // if (sim.size() != 0) throw new RuntimeException("Test (23) failed"); - // if (iim.size() != 0) throw new RuntimeException("Test (24) failed"); + checkThat(sim.put("key1", 3) == 1); + checkThat(iim.put(1, 3) == 1); - // sim.put("key", 1); - // sim.put("key2", 2); - // iim.put(1, 1); - // iim.put(2, 2); + checkThat(sim.size() == 2); + checkThat(iim.size() == 2); + checkThat(sim.get("key1") == 3); + checkThat(iim.get(1) == 3); - // if (sim.get("key") != 1) throw new RuntimeException("Test (25) failed"); - // if (sim.get("key2") != 2) throw new RuntimeException("Test (26) failed"); - // if (iim.get(1) != 1) throw new RuntimeException("Test (27) failed"); - // if (iim.get(2) != 2) throw new RuntimeException("Test (28) failed"); + java.util.Set> sim_es = sim.entrySet(); + java.util.Map sim_default = new java.util.HashMap(); + sim_default.put("key1", 3); + sim_default.put("key2", 2); + java.util.Set> sim_es_default = sim_default.entrySet(); + checkThat(sim_es.size() == sim_es_default.size()); + for (java.util.Map.Entry entry : sim_es) { + checkThat(sim_es_default.contains(entry)); + checkThat(sim_default.containsKey(entry.getKey())); + checkThat(sim_default.containsValue(entry.getValue())); - // sim.put("key", 3); - // iim.put(1, 3); + Integer oldValue = entry.getValue(); + entry.setValue(oldValue + 1); + checkThat(sim.get(entry.getKey()) == (oldValue + 1)); + } - // if (sim.get("key") != 3) throw new RuntimeException("Test (29) failed"); - // if (sim.get("key2") != 2) throw new RuntimeException("Test (30) failed"); - // if (iim.get(1) != 3) throw new RuntimeException("Test (31) failed"); - // if (iim.get(2) != 2) throw new RuntimeException("Test (32) failed"); + java.util.Set> iim_es = iim.entrySet(); + java.util.Map iim_default = new java.util.HashMap(); + iim_default.put(1, 3); + iim_default.put(2, 2); + java.util.Set> iim_es_default = iim_default.entrySet(); + checkThat(iim_es.size() == iim_es_default.size()); + for (java.util.Map.Entry entry : iim_es) { + checkThat(iim_es_default.contains(entry)); + checkThat(iim_default.containsKey(entry.getKey())); + checkThat(iim_default.containsValue(entry.getValue())); + + Integer oldValue = entry.getValue(); + entry.setValue(oldValue + 1); + checkThat(iim.get(entry.getKey()) == (oldValue + 1)); + } } } diff --git a/Examples/test-suite/java/li_std_set_runme.java b/Examples/test-suite/java/li_std_set_runme.java index 7bbd3fced..9763484c2 100644 --- a/Examples/test-suite/java/li_std_set_runme.java +++ b/Examples/test-suite/java/li_std_set_runme.java @@ -11,49 +11,48 @@ public class li_std_set_runme { } } - public static void failTest(int testNum) throws Throwable { - throw new RuntimeException("Test failed: " + testNum); - } - - public static void checkThat(boolean mustBeTrue, int testNum) throws Throwable { - if (!mustBeTrue) failTest(testNum); + public static void checkThat(boolean mustBeTrue) throws Throwable { + if (!mustBeTrue) { + // Index [2], since this function is one hop away from main, and [1] is the current method. + throw new RuntimeException("Test failed at line number " + Thread.currentThread().getStackTrace()[2].getLineNumber()); + } } public static void main(String argv[]) throws Throwable { java.util.AbstractSet ss = new StringSet(); - checkThat(ss.isEmpty(), 1); - checkThat(!ss.contains("key"), 2); - checkThat(!ss.remove("key"), 3); + checkThat(ss.isEmpty()); + checkThat(!ss.contains("key")); + checkThat(!ss.remove("key")); - checkThat(ss.add("key"), 4); - checkThat(!ss.add("key"), 5); - checkThat(ss.contains("key"), 6); - checkThat(ss.remove("key"), 7); - checkThat(ss.isEmpty(), 8); - checkThat(ss.size() == 0, 9); + checkThat(ss.add("key")); + checkThat(!ss.add("key")); + checkThat(ss.contains("key")); + checkThat(ss.remove("key")); + checkThat(ss.isEmpty()); + checkThat(ss.size() == 0); - checkThat(ss.add("key1"), 10); - checkThat(ss.add("key2"), 11); - checkThat(ss.add("key3"), 12); - checkThat(ss.size() == 3, 13); + checkThat(ss.add("key1")); + checkThat(ss.add("key2")); + checkThat(ss.add("key3")); + checkThat(ss.size() == 3); ss.clear(); - checkThat(ss.isEmpty(), 14); - checkThat(ss.size() == 0, 15); + checkThat(ss.isEmpty()); + checkThat(ss.size() == 0); - checkThat(ss.addAll(java.util.Arrays.asList("one", "two", "three")), 16); - checkThat(ss.size() == 3, 17); - checkThat(ss.contains("one"), 18); - checkThat(!ss.contains("four"), 19); + checkThat(ss.addAll(java.util.Arrays.asList("one", "two", "three"))); + checkThat(ss.size() == 3); + checkThat(ss.contains("one")); + checkThat(!ss.contains("four")); - checkThat(ss.containsAll(java.util.Arrays.asList("one", "two", "three")), 20); - checkThat(ss.containsAll(java.util.Arrays.asList("one", "two")), 21); - checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "four")), 22); - checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "three", "four")), 23); + checkThat(ss.containsAll(java.util.Arrays.asList("one", "two", "three"))); + checkThat(ss.containsAll(java.util.Arrays.asList("one", "two"))); + checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "four"))); + checkThat(!ss.containsAll(java.util.Arrays.asList("one", "two", "three", "four"))); - checkThat(!ss.addAll(java.util.Arrays.asList("one", "two", "three")), 24); + checkThat(!ss.addAll(java.util.Arrays.asList("one", "two", "three"))); java.util.Set found = new java.util.HashSet(); java.util.Iterator itr = ss.iterator(); @@ -61,16 +60,16 @@ public class li_std_set_runme { found.add(itr.next()); } - checkThat(ss.containsAll(found), 25); - checkThat(found.containsAll(ss), 26); + checkThat(ss.containsAll(found)); + checkThat(found.containsAll(ss)); java.util.AbstractSet ss2 = new StringSet(ss); - checkThat(ss2.containsAll(ss), 27); - checkThat(ss.containsAll(ss2), 28); + checkThat(ss2.containsAll(ss)); + checkThat(ss.containsAll(ss2)); - checkThat(!ss.removeAll(java.util.Arrays.asList("five", "four")), 29); - checkThat(ss.removeAll(found), 30); - checkThat(ss.isEmpty(), 31); - checkThat(ss.size() == 0, 32); + checkThat(!ss.removeAll(java.util.Arrays.asList("five", "four"))); + checkThat(ss.removeAll(found)); + checkThat(ss.isEmpty()); + checkThat(ss.size() == 0); } } diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index 4169a18b4..d59ceb8fc 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -7,7 +7,6 @@ * ----------------------------------------------------------------------------- */ %include -%include // ------------------------------------------------------------------------ // std::map @@ -31,9 +30,19 @@ %javamethodmodifiers std::map::sizeImpl "private"; %javamethodmodifiers std::map::containsImpl "private"; -%javamethodmodifiers std::map::getImpl "private"; -%javamethodmodifiers std::map::putImpl "private"; -%javamethodmodifiers std::map::removeImpl "private"; +%javamethodmodifiers std::map::putUnchecked "private"; +%javamethodmodifiers std::map::removeUnchecked "private"; +%javamethodmodifiers std::map::find "private"; +%javamethodmodifiers std::map::begin "private"; +%javamethodmodifiers std::map::end "private"; + +%rename(Iterator) std::map::iterator; +%nodefaultctor std::map::iterator; +%javamethodmodifiers std::map::iterator::getNextUnchecked "private"; +%javamethodmodifiers std::map::iterator::isNot "private"; +%javamethodmodifiers std::map::iterator::getKey "private"; +%javamethodmodifiers std::map::iterator::getValue "private"; +%javamethodmodifiers std::map::iterator::setValue "private"; namespace std { @@ -48,47 +57,88 @@ template > return sizeImpl(); } - public boolean containsKey(Object object) { - if (!(object instanceof $typemap(jboxtype, KeyType))) { + public boolean containsKey(Object key) { + if (!(key instanceof $typemap(jboxtype, KeyType))) { return false; } - return containsImpl(($typemap(jboxtype, KeyType))object); + return containsImpl(($typemap(jboxtype, KeyType))key); } - public $typemap(jboxtype, ValueType) get(Object object) { - if (!(object instanceof $typemap(jboxtype, KeyType))) { + public $typemap(jboxtype, ValueType) get(Object key) { + if (!(key instanceof $typemap(jboxtype, KeyType))) { return null; } - try { - getImpl(($typemap(jboxtype, KeyType)) object); - } catch (IndexOutOfBoundsException e) {} + Iterator itr = find(($typemap(jboxtype, KeyType)) key); + if (itr.isNot(end())) { + return itr.getValue(); + } return null; } public $typemap(jboxtype, ValueType) put($typemap(jboxtype, KeyType) key, $typemap(jboxtype, ValueType) value) { - try { - $typemap(jboxtype, ValueType) oldValue = putImpl(key, value); + Iterator itr = find(($typemap(jboxtype, KeyType)) key); + if (itr.isNot(end())) { + $typemap(jboxtype, ValueType) oldValue = itr.getValue(); + itr.setValue(value); return oldValue; - } catch (IndexOutOfBoundsException e) {} - - return null; + } else { + putUnchecked(key, value); + return null; + } } - public $typemap(jboxtype, ValueType) remove($typemap(jboxtype, KeyType) key) { - try { - $typemap(jboxtype, ValueType) oldValue = removeImpl(key); - return oldValue; - } catch (IndexOutOfBoundsException e) {} + public $typemap(jboxtype, ValueType) remove(Object key) { + if (!(key instanceof $typemap(jboxtype, KeyType))) { + return null; + } - return null; + Iterator itr = find(($typemap(jboxtype, KeyType)) key); + if (itr.isNot(end())) { + $typemap(jboxtype, ValueType) oldValue = itr.getValue(); + removeUnchecked(itr); + return oldValue; + } else { + return null; + } } public java.util.Set> entrySet() { - throw new RuntimeException("Stub"); + java.util.Set> setToReturn = + new java.util.HashSet>(); + + Iterator itr = begin(); + final Iterator end = end(); + while(itr.isNot(end)) { + setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)>() { + private Iterator iterator; + + private Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)> init(Iterator iterator) { + this.iterator = iterator; + return this; + } + + public $typemap(jboxtype, KeyType) getKey() { + return iterator.getKey(); + } + + public $typemap(jboxtype, ValueType) getValue() { + return iterator.getValue(); + } + + public $typemap(jboxtype, ValueType) setValue($typemap(jboxtype, ValueType) newValue) { + $typemap(jboxtype, ValueType) oldValue = iterator.getValue(); + iterator.setValue(newValue); + return oldValue; + } + }.init(itr)); + itr = itr.getNextUnchecked(); + } + + return setToReturn; } %} @@ -96,9 +146,37 @@ template > map(); map(const map&); + struct iterator { + %extend { + std::map::iterator getNextUnchecked() { + std::map::iterator copy = (*$self); + return ++copy; + } + + bool isNot(const iterator other) const { + return (*$self != other); + } + + KeyType getKey() const { + return (*$self)->first; + } + + ValueType getValue() const { + return (*$self)->second; + } + + void setValue(const ValueType& newValue) { + (*$self)->second = newValue; + } + } + }; + %rename(isEmpty) empty; bool empty() const; void clear(); + iterator find(const KeyType&); + iterator begin(); + iterator end(); %extend { %fragment("SWIG_MapSize"); @@ -110,36 +188,12 @@ template > return (self->count(key) > 0); } - const ValueType& getImpl(const KeyType& key) throw (std::out_of_range) { - std::map::iterator itr = self->find(key); - if (itr != self->end()) { - return itr->second; - } else { - throw std::out_of_range("map::get() - key not found"); - } + void putUnchecked(const KeyType& key, const ValueType& value) { + (*self)[key] = value; } - ValueType putImpl(const KeyType& key, const ValueType& value) { - std::map::iterator itr = self->find(key); - if (itr != self->end()) { - ValueType oldValue = itr->second; - itr->second = value; - return oldValue; - } else { - (*self)[key] = value; - throw std::out_of_range("map::put() - no existing value for key"); - } - } - - ValueType removeImpl(const KeyType& key) throw (std::out_of_range) { - std::map::iterator itr = self->find(key); - if (itr != self->end()) { - ValueType oldValue = itr->second; - self->erase(itr); - return oldValue; - } else { - throw std::out_of_range("map::remove() - key not found"); - } + void removeUnchecked(const std::map::iterator itr) { + self->erase(itr); } } }; diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i index 434292b07..b0e8b3e40 100644 --- a/Lib/java/std_unordered_map.i +++ b/Lib/java/std_unordered_map.i @@ -2,6 +2,8 @@ * std_unordered_map.i * * SWIG typemaps for std::unordered_map + * The Java proxy class extends java.util.AbstractMap. The std::unordered_map + * container looks and feels much like a java.util.HashMap from Java. * ----------------------------------------------------------------------------- */ %include @@ -15,51 +17,185 @@ #include %} +%fragment("SWIG_MapSize", "header", fragment="SWIG_JavaIntFromSize_t") { + SWIGINTERN jint SWIG_MapSize(size_t size) { + jint sz = SWIG_JavaIntFromSize_t(size); + if (sz == -1) { + throw std::out_of_range("map size is too large to fit into a Java int"); + } + + return sz; + } +} + +%javamethodmodifiers std::unordered_map::sizeImpl "private"; +%javamethodmodifiers std::unordered_map::containsImpl "private"; +%javamethodmodifiers std::unordered_map::putUnchecked "private"; +%javamethodmodifiers std::unordered_map::removeUnchecked "private"; +%javamethodmodifiers std::unordered_map::find "private"; +%javamethodmodifiers std::unordered_map::begin "private"; +%javamethodmodifiers std::unordered_map::end "private"; + +%rename(Iterator) std::unordered_map::iterator; +%nodefaultctor std::unordered_map::iterator; +%javamethodmodifiers std::unordered_map::iterator::getNextUnchecked "private"; +%javamethodmodifiers std::unordered_map::iterator::isNot "private"; +%javamethodmodifiers std::unordered_map::iterator::getKey "private"; +%javamethodmodifiers std::unordered_map::iterator::getValue "private"; +%javamethodmodifiers std::unordered_map::iterator::setValue "private"; + namespace std { -template class unordered_map { - public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef KeyType key_type; - typedef MappedType mapped_type; - unordered_map(); - unordered_map(const unordered_map&); +template class unordered_map { - unsigned int size() const; +%typemap(javabase) std::unordered_map + "java.util.AbstractMap<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)>" + +%proxycode %{ + + public int size() { + return sizeImpl(); + } + + public boolean containsKey(Object key) { + if (!(key instanceof $typemap(jboxtype, KeyType))) { + return false; + } + + return containsImpl(($typemap(jboxtype, KeyType))key); + } + + public $typemap(jboxtype, ValueType) get(Object key) { + if (!(key instanceof $typemap(jboxtype, KeyType))) { + return null; + } + + Iterator itr = find(($typemap(jboxtype, KeyType)) key); + if (itr.isNot(end())) { + return itr.getValue(); + } + + return null; + } + + public $typemap(jboxtype, ValueType) put($typemap(jboxtype, KeyType) key, + $typemap(jboxtype, ValueType) value) { + Iterator itr = find(($typemap(jboxtype, KeyType)) key); + if (itr.isNot(end())) { + $typemap(jboxtype, ValueType) oldValue = itr.getValue(); + itr.setValue(value); + return oldValue; + } else { + putUnchecked(key, value); + return null; + } + } + + public $typemap(jboxtype, ValueType) remove(Object key) { + if (!(key instanceof $typemap(jboxtype, KeyType))) { + return null; + } + + Iterator itr = find(($typemap(jboxtype, KeyType)) key); + if (itr.isNot(end())) { + $typemap(jboxtype, ValueType) oldValue = itr.getValue(); + removeUnchecked(itr); + return oldValue; + } else { + return null; + } + } + + public java.util.Set> entrySet() { + java.util.Set> setToReturn = + new java.util.HashSet>(); + + Iterator itr = begin(); + final Iterator end = end(); + while(itr.isNot(end)) { + setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)>() { + private Iterator iterator; + + private Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)> init(Iterator iterator) { + this.iterator = iterator; + return this; + } + + public $typemap(jboxtype, KeyType) getKey() { + return iterator.getKey(); + } + + public $typemap(jboxtype, ValueType) getValue() { + return iterator.getValue(); + } + + public $typemap(jboxtype, ValueType) setValue($typemap(jboxtype, ValueType) newValue) { + $typemap(jboxtype, ValueType) oldValue = iterator.getValue(); + iterator.setValue(newValue); + return oldValue; + } + }.init(itr)); + itr = itr.getNextUnchecked(); + } + + return setToReturn; + } +%} + + public: + unordered_map(); + unordered_map(const unordered_map&); + + struct iterator { + %extend { + std::unordered_map::iterator getNextUnchecked() { + std::unordered_map::iterator copy = (*$self); + return ++copy; + } + + bool isNot(const iterator other) const { + return (*$self != other); + } + + KeyType getKey() const { + return (*$self)->first; + } + + ValueType getValue() const { + return (*$self)->second; + } + + void setValue(const ValueType& newValue) { + (*$self)->second = newValue; + } + } + }; + + %rename(isEmpty) empty; bool empty() const; void clear(); - + iterator find(const KeyType&); + iterator begin(); + iterator end(); %extend { - const MappedType& get(const KeyType& key) throw (std::out_of_range) { - std::unordered_map::iterator i = self->find(key); + %fragment("SWIG_MapSize"); - if (i != self->end()) { - return i->second; - } else { - throw std::out_of_range("key not found"); - } + jint sizeImpl() const throw (std::out_of_range) { + return SWIG_MapSize(self->size()); } - void set(const KeyType& key, const MappedType& x) { - (*self)[key] = x; + bool containsImpl(const KeyType& key) { + return (self->count(key) > 0); } - void del(const KeyType& key) throw (std::out_of_range) { - std::unordered_map::iterator i = self->find(key); - - if (i != self->end()) { - self->erase(i); - } else { - throw std::out_of_range("key not found"); - } + void putUnchecked(const KeyType& key, const ValueType& value) { + (*self)[key] = value; } - bool has_key(const KeyType& key) { - std::unordered_map::iterator i = self->find(key); - return i != self->end(); + void removeUnchecked(const std::unordered_map::iterator itr) { + self->erase(itr); } } }; -} // namespace std +} From 7e9f1a79724d6c0d480999958109f2a2f2e3494f Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Thu, 27 Dec 2018 01:15:18 -0500 Subject: [PATCH 07/26] Add to STL file as well --- Lib/java/std_set.i | 2 +- Lib/java/std_unordered_set.i | 2 +- Lib/java/stl.i | 7 +++++-- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i index 57613f322..de0c31fba 100644 --- a/Lib/java/std_set.i +++ b/Lib/java/std_set.i @@ -186,4 +186,4 @@ class set { } }; -} // namespace std \ No newline at end of file +} // namespace std diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i index 4074d8045..ca9af0f19 100644 --- a/Lib/java/std_unordered_set.i +++ b/Lib/java/std_unordered_set.i @@ -186,4 +186,4 @@ class unordered_set { } }; -} // namespace std \ No newline at end of file +} // namespace std diff --git a/Lib/java/stl.i b/Lib/java/stl.i index 04f86014f..6f2a4342a 100644 --- a/Lib/java/stl.i +++ b/Lib/java/stl.i @@ -3,8 +3,11 @@ * ----------------------------------------------------------------------------- */ %include -%include -%include %include %include +%include +%include +%include +%include +%include From 945bd7c8088af6813195d9584e6b373e47341363 Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Thu, 27 Dec 2018 11:47:16 -0500 Subject: [PATCH 08/26] Remove c++11 from stl.i --- Lib/java/stl.i | 3 --- 1 file changed, 3 deletions(-) diff --git a/Lib/java/stl.i b/Lib/java/stl.i index 6f2a4342a..a04adf7b6 100644 --- a/Lib/java/stl.i +++ b/Lib/java/stl.i @@ -7,7 +7,4 @@ %include %include %include -%include -%include %include - From d06ffe1087c714d163c09e57f6f3c20ccbcd4922 Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Mon, 4 Feb 2019 22:23:13 -0500 Subject: [PATCH 09/26] Legacy macros, protected iterator, typedefs --- Lib/java/std_map.i | 70 +++++++++++++++++++++++------------- Lib/java/std_set.i | 6 ++++ Lib/java/std_unordered_map.i | 54 +++++++++++++++------------- Lib/java/std_unordered_set.i | 6 ++++ 4 files changed, 87 insertions(+), 49 deletions(-) diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index d59ceb8fc..5b7517ad5 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -46,10 +46,10 @@ namespace std { -template > class map { +template > class map { -%typemap(javabase) std::map - "java.util.AbstractMap<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)>" +%typemap(javabase) std::map + "java.util.AbstractMap<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>" %proxycode %{ @@ -65,7 +65,7 @@ template > return containsImpl(($typemap(jboxtype, KeyType))key); } - public $typemap(jboxtype, ValueType) get(Object key) { + public $typemap(jboxtype, MappedType) get(Object key) { if (!(key instanceof $typemap(jboxtype, KeyType))) { return null; } @@ -78,11 +78,11 @@ template > return null; } - public $typemap(jboxtype, ValueType) put($typemap(jboxtype, KeyType) key, - $typemap(jboxtype, ValueType) value) { + public $typemap(jboxtype, MappedType) put($typemap(jboxtype, KeyType) key, + $typemap(jboxtype, MappedType) value) { Iterator itr = find(($typemap(jboxtype, KeyType)) key); if (itr.isNot(end())) { - $typemap(jboxtype, ValueType) oldValue = itr.getValue(); + $typemap(jboxtype, MappedType) oldValue = itr.getValue(); itr.setValue(value); return oldValue; } else { @@ -91,14 +91,14 @@ template > } } - public $typemap(jboxtype, ValueType) remove(Object key) { + public $typemap(jboxtype, MappedType) remove(Object key) { if (!(key instanceof $typemap(jboxtype, KeyType))) { return null; } Iterator itr = find(($typemap(jboxtype, KeyType)) key); if (itr.isNot(end())) { - $typemap(jboxtype, ValueType) oldValue = itr.getValue(); + $typemap(jboxtype, MappedType) oldValue = itr.getValue(); removeUnchecked(itr); return oldValue; } else { @@ -106,17 +106,17 @@ template > } } - public java.util.Set> entrySet() { - java.util.Set> setToReturn = - new java.util.HashSet>(); + public java.util.Set> entrySet() { + java.util.Set> setToReturn = + new java.util.HashSet>(); Iterator itr = begin(); final Iterator end = end(); while(itr.isNot(end)) { - setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)>() { + setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>() { private Iterator iterator; - private Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)> init(Iterator iterator) { + private Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)> init(Iterator iterator) { this.iterator = iterator; return this; } @@ -125,12 +125,12 @@ template > return iterator.getKey(); } - public $typemap(jboxtype, ValueType) getValue() { + public $typemap(jboxtype, MappedType) getValue() { return iterator.getValue(); } - public $typemap(jboxtype, ValueType) setValue($typemap(jboxtype, ValueType) newValue) { - $typemap(jboxtype, ValueType) oldValue = iterator.getValue(); + public $typemap(jboxtype, MappedType) setValue($typemap(jboxtype, MappedType) newValue) { + $typemap(jboxtype, MappedType) oldValue = iterator.getValue(); iterator.setValue(newValue); return oldValue; } @@ -143,17 +143,24 @@ template > %} public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef KeyType key_type; + typedef MappedType mapped_type; + typedef Compare key_compare; + map(); - map(const map&); + map(const map&); struct iterator { + %typemap(javaclassmodifiers) iterator "protected class" %extend { - std::map::iterator getNextUnchecked() { - std::map::iterator copy = (*$self); + std::map::iterator getNextUnchecked() { + std::map::iterator copy = (*$self); return ++copy; } - bool isNot(const iterator other) const { + bool isNot(iterator other) const { return (*$self != other); } @@ -161,11 +168,11 @@ template > return (*$self)->first; } - ValueType getValue() const { + MappedType getValue() const { return (*$self)->second; } - void setValue(const ValueType& newValue) { + void setValue(const MappedType& newValue) { (*$self)->second = newValue; } } @@ -188,14 +195,27 @@ template > return (self->count(key) > 0); } - void putUnchecked(const KeyType& key, const ValueType& value) { + void putUnchecked(const KeyType& key, const MappedType& value) { (*self)[key] = value; } - void removeUnchecked(const std::map::iterator itr) { + void removeUnchecked(const std::map::iterator itr) { self->erase(itr); } } }; +// Legacy macros (deprecated) +%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO) +#warning "specialize_std_map_on_key ignored - macro is deprecated and no longer necessary" +%enddef + +%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO) +#warning "specialize_std_map_on_value ignored - macro is deprecated and no longer necessary" +%enddef + +%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO) +#warning "specialize_std_map_on_both ignored - macro is deprecated and no longer necessary" +%enddef + } diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i index de0c31fba..6f557f627 100644 --- a/Lib/java/std_set.i +++ b/Lib/java/std_set.i @@ -134,6 +134,7 @@ class set { public: struct iterator { + %typemap(javaclassmodifiers) iterator "protected class" %extend { void incrementUnchecked() { ++(*$self); @@ -149,6 +150,11 @@ class set { } }; + typedef KeyType key_type; + typedef KeyType value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + set(); set(const set&); diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i index b0e8b3e40..405e0fba5 100644 --- a/Lib/java/std_unordered_map.i +++ b/Lib/java/std_unordered_map.i @@ -46,10 +46,10 @@ namespace std { -template class unordered_map { +template class unordered_map { -%typemap(javabase) std::unordered_map - "java.util.AbstractMap<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)>" +%typemap(javabase) std::unordered_map + "java.util.AbstractMap<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>" %proxycode %{ @@ -65,7 +65,7 @@ template class unordered_map { return containsImpl(($typemap(jboxtype, KeyType))key); } - public $typemap(jboxtype, ValueType) get(Object key) { + public $typemap(jboxtype, MappedType) get(Object key) { if (!(key instanceof $typemap(jboxtype, KeyType))) { return null; } @@ -78,11 +78,11 @@ template class unordered_map { return null; } - public $typemap(jboxtype, ValueType) put($typemap(jboxtype, KeyType) key, - $typemap(jboxtype, ValueType) value) { + public $typemap(jboxtype, MappedType) put($typemap(jboxtype, KeyType) key, + $typemap(jboxtype, MappedType) value) { Iterator itr = find(($typemap(jboxtype, KeyType)) key); if (itr.isNot(end())) { - $typemap(jboxtype, ValueType) oldValue = itr.getValue(); + $typemap(jboxtype, MappedType) oldValue = itr.getValue(); itr.setValue(value); return oldValue; } else { @@ -91,14 +91,14 @@ template class unordered_map { } } - public $typemap(jboxtype, ValueType) remove(Object key) { + public $typemap(jboxtype, MappedType) remove(Object key) { if (!(key instanceof $typemap(jboxtype, KeyType))) { return null; } Iterator itr = find(($typemap(jboxtype, KeyType)) key); if (itr.isNot(end())) { - $typemap(jboxtype, ValueType) oldValue = itr.getValue(); + $typemap(jboxtype, MappedType) oldValue = itr.getValue(); removeUnchecked(itr); return oldValue; } else { @@ -106,17 +106,17 @@ template class unordered_map { } } - public java.util.Set> entrySet() { - java.util.Set> setToReturn = - new java.util.HashSet>(); + public java.util.Set> entrySet() { + java.util.Set> setToReturn = + new java.util.HashSet>(); Iterator itr = begin(); final Iterator end = end(); while(itr.isNot(end)) { - setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)>() { + setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>() { private Iterator iterator; - private Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, ValueType)> init(Iterator iterator) { + private Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)> init(Iterator iterator) { this.iterator = iterator; return this; } @@ -125,12 +125,12 @@ template class unordered_map { return iterator.getKey(); } - public $typemap(jboxtype, ValueType) getValue() { + public $typemap(jboxtype, MappedType) getValue() { return iterator.getValue(); } - public $typemap(jboxtype, ValueType) setValue($typemap(jboxtype, ValueType) newValue) { - $typemap(jboxtype, ValueType) oldValue = iterator.getValue(); + public $typemap(jboxtype, MappedType) setValue($typemap(jboxtype, MappedType) newValue) { + $typemap(jboxtype, MappedType) oldValue = iterator.getValue(); iterator.setValue(newValue); return oldValue; } @@ -143,13 +143,19 @@ template class unordered_map { %} public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef KeyType key_type; + typedef MappedType mapped_type; + unordered_map(); - unordered_map(const unordered_map&); + unordered_map(const unordered_map&); struct iterator { + %typemap(javaclassmodifiers) iterator "protected class" %extend { - std::unordered_map::iterator getNextUnchecked() { - std::unordered_map::iterator copy = (*$self); + std::unordered_map::iterator getNextUnchecked() { + std::unordered_map::iterator copy = (*$self); return ++copy; } @@ -161,11 +167,11 @@ template class unordered_map { return (*$self)->first; } - ValueType getValue() const { + MappedType getValue() const { return (*$self)->second; } - void setValue(const ValueType& newValue) { + void setValue(const MappedType& newValue) { (*$self)->second = newValue; } } @@ -188,11 +194,11 @@ template class unordered_map { return (self->count(key) > 0); } - void putUnchecked(const KeyType& key, const ValueType& value) { + void putUnchecked(const KeyType& key, const MappedType& value) { (*self)[key] = value; } - void removeUnchecked(const std::unordered_map::iterator itr) { + void removeUnchecked(const std::unordered_map::iterator itr) { self->erase(itr); } } diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i index ca9af0f19..b408c47de 100644 --- a/Lib/java/std_unordered_set.i +++ b/Lib/java/std_unordered_set.i @@ -134,6 +134,7 @@ class unordered_set { public: struct iterator { + %typemap(javaclassmodifiers) iterator "protected class" %extend { void incrementUnchecked() { ++(*$self); @@ -149,6 +150,11 @@ class unordered_set { } }; + typedef KeyType key_type; + typedef KeyType value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + unordered_set(); unordered_set(const unordered_set&); From 437037a3e6ec0e64785ce084853ba406997466f3 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Mon, 11 Feb 2019 19:49:42 +0000 Subject: [PATCH 10/26] Replicate some cosmetic changes from std_map.i into std_set.i, std_unordered_map.i, std_unordered_set.i. --- Lib/java/std_map.i | 2 +- Lib/java/std_set.i | 46 ++++++++++++++++++------------------ Lib/java/std_unordered_map.i | 4 ++-- Lib/java/std_unordered_set.i | 46 ++++++++++++++++++------------------ 4 files changed, 49 insertions(+), 49 deletions(-) diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index 5b7517ad5..7df94b0b7 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -112,7 +112,7 @@ template Iterator itr = begin(); final Iterator end = end(); - while(itr.isNot(end)) { + while (itr.isNot(end)) { setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>() { private Iterator iterator; diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i index 6f557f627..020ab67f7 100644 --- a/Lib/java/std_set.i +++ b/Lib/java/std_set.i @@ -43,12 +43,12 @@ namespace std { -template +template class set { -%typemap(javabase) std::set "java.util.AbstractSet<$typemap(jboxtype, KeyType)>" +%typemap(javabase) std::set "java.util.AbstractSet<$typemap(jboxtype, T)>" %proxycode %{ - public $javaclassname(java.util.Collection collection) { + public $javaclassname(java.util.Collection collection) { this(); addAll(collection); } @@ -57,34 +57,34 @@ class set { return sizeImpl(); } - public boolean addAll(java.util.Collection collection) { + public boolean addAll(java.util.Collection collection) { boolean didAddElement = false; for (Object object : collection) { - didAddElement |= add(($typemap(jboxtype, KeyType))object); + didAddElement |= add(($typemap(jboxtype, T))object); } return didAddElement; } - public java.util.Iterator<$typemap(jboxtype, KeyType)> iterator() { - return new java.util.Iterator<$typemap(jboxtype, KeyType)>() { + public java.util.Iterator<$typemap(jboxtype, T)> iterator() { + return new java.util.Iterator<$typemap(jboxtype, T)>() { private Iterator curr; private Iterator end; - private java.util.Iterator<$typemap(jboxtype, KeyType)> init() { + private java.util.Iterator<$typemap(jboxtype, T)> init() { curr = $javaclassname.this.begin(); end = $javaclassname.this.end(); return this; } - public $typemap(jboxtype, KeyType) next() { + public $typemap(jboxtype, T) next() { if (!hasNext()) { throw new java.util.NoSuchElementException(); } // Save the current position, increment it, // then return the value at the position before the increment. - final $typemap(jboxtype, KeyType) currValue = curr.derefUnchecked(); + final $typemap(jboxtype, T) currValue = curr.derefUnchecked(); curr.incrementUnchecked(); return currValue; } @@ -106,11 +106,11 @@ class set { } public boolean contains(Object object) { - if (!(object instanceof $typemap(jboxtype, KeyType))) { + if (!(object instanceof $typemap(jboxtype, T))) { return false; } - return containsImpl(($typemap(jboxtype, KeyType))object); + return containsImpl(($typemap(jboxtype, T))object); } public boolean removeAll(java.util.Collection collection) { @@ -123,11 +123,11 @@ class set { } public boolean remove(Object object) { - if (!(object instanceof $typemap(jboxtype, KeyType))) { + if (!(object instanceof $typemap(jboxtype, T))) { return false; } - return removeImpl(($typemap(jboxtype, KeyType))object); + return removeImpl(($typemap(jboxtype, T))object); } %} @@ -140,23 +140,23 @@ class set { ++(*$self); } - KeyType derefUnchecked() const { + T derefUnchecked() const { return **$self; } - bool isNot(const iterator other) const { + bool isNot(iterator other) const { return (*$self != other); } } }; - typedef KeyType key_type; - typedef KeyType value_type; + typedef T key_type; + typedef T value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; set(); - set(const set&); + set(const set&); %rename(isEmpty) empty; bool empty() const; @@ -168,17 +168,17 @@ class set { %fragment("SWIG_SetSize"); // Returns whether item was inserted. - bool add(const KeyType& key) { + bool add(const T& key) { return self->insert(key).second; } // Returns whether set contains key. - bool containsImpl(const KeyType& key) { + bool containsImpl(const T& key) { return (self->count(key) > 0); } // Returns whether the item was erased. - bool removeImpl(const KeyType& key) { + bool removeImpl(const T& key) { return (self->erase(key) > 0); } @@ -192,4 +192,4 @@ class set { } }; -} // namespace std +} diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i index 405e0fba5..3b926b0e6 100644 --- a/Lib/java/std_unordered_map.i +++ b/Lib/java/std_unordered_map.i @@ -112,7 +112,7 @@ template class unordered_map { Iterator itr = begin(); final Iterator end = end(); - while(itr.isNot(end)) { + while (itr.isNot(end)) { setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>() { private Iterator iterator; @@ -159,7 +159,7 @@ template class unordered_map { return ++copy; } - bool isNot(const iterator other) const { + bool isNot(iterator other) const { return (*$self != other); } diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i index b408c47de..13d1fa4f9 100644 --- a/Lib/java/std_unordered_set.i +++ b/Lib/java/std_unordered_set.i @@ -43,12 +43,12 @@ namespace std { -template +template class unordered_set { -%typemap(javabase) std::unordered_set "java.util.AbstractSet<$typemap(jboxtype, KeyType)>" +%typemap(javabase) std::unordered_set "java.util.AbstractSet<$typemap(jboxtype, T)>" %proxycode %{ - public $javaclassname(java.util.Collection collection) { + public $javaclassname(java.util.Collection collection) { this(); addAll(collection); } @@ -57,34 +57,34 @@ class unordered_set { return sizeImpl(); } - public boolean addAll(java.util.Collection collection) { + public boolean addAll(java.util.Collection collection) { boolean didAddElement = false; for (Object object : collection) { - didAddElement |= add(($typemap(jboxtype, KeyType))object); + didAddElement |= add(($typemap(jboxtype, T))object); } return didAddElement; } - public java.util.Iterator<$typemap(jboxtype, KeyType)> iterator() { - return new java.util.Iterator<$typemap(jboxtype, KeyType)>() { + public java.util.Iterator<$typemap(jboxtype, T)> iterator() { + return new java.util.Iterator<$typemap(jboxtype, T)>() { private Iterator curr; private Iterator end; - private java.util.Iterator<$typemap(jboxtype, KeyType)> init() { + private java.util.Iterator<$typemap(jboxtype, T)> init() { curr = $javaclassname.this.begin(); end = $javaclassname.this.end(); return this; } - public $typemap(jboxtype, KeyType) next() { + public $typemap(jboxtype, T) next() { if (!hasNext()) { throw new java.util.NoSuchElementException(); } // Save the current position, increment it, // then return the value at the position before the increment. - final $typemap(jboxtype, KeyType) currValue = curr.derefUnchecked(); + final $typemap(jboxtype, T) currValue = curr.derefUnchecked(); curr.incrementUnchecked(); return currValue; } @@ -106,11 +106,11 @@ class unordered_set { } public boolean contains(Object object) { - if (!(object instanceof $typemap(jboxtype, KeyType))) { + if (!(object instanceof $typemap(jboxtype, T))) { return false; } - return containsImpl(($typemap(jboxtype, KeyType))object); + return containsImpl(($typemap(jboxtype, T))object); } public boolean removeAll(java.util.Collection collection) { @@ -123,11 +123,11 @@ class unordered_set { } public boolean remove(Object object) { - if (!(object instanceof $typemap(jboxtype, KeyType))) { + if (!(object instanceof $typemap(jboxtype, T))) { return false; } - return removeImpl(($typemap(jboxtype, KeyType))object); + return removeImpl(($typemap(jboxtype, T))object); } %} @@ -140,23 +140,23 @@ class unordered_set { ++(*$self); } - KeyType derefUnchecked() const { + T derefUnchecked() const { return **$self; } - bool isNot(const iterator other) const { + bool isNot(iterator other) const { return (*$self != other); } } }; - typedef KeyType key_type; - typedef KeyType value_type; + typedef T key_type; + typedef T value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; unordered_set(); - unordered_set(const unordered_set&); + unordered_set(const unordered_set&); %rename(isEmpty) empty; bool empty() const; @@ -168,17 +168,17 @@ class unordered_set { %fragment("SWIG_UnorderedSetSize"); // Returns whether item was inserted. - bool add(const KeyType& key) { + bool add(const T& key) { return self->insert(key).second; } // Returns whether set contains key. - bool containsImpl(const KeyType& key) { + bool containsImpl(const T& key) { return (self->count(key) > 0); } // Returns whether the item was erased. - bool removeImpl(const KeyType& key) { + bool removeImpl(const T& key) { return (self->erase(key) > 0); } @@ -192,4 +192,4 @@ class unordered_set { } }; -} // namespace std +} From 9849174d936b717b37e35b39011b6640b3d36901 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Mon, 11 Feb 2019 19:53:33 +0000 Subject: [PATCH 11/26] Nicer looking generated Java container code --- Lib/java/std_map.i | 3 +-- Lib/java/std_unordered_map.i | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index 7df94b0b7..b177f9021 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -78,8 +78,7 @@ template return null; } - public $typemap(jboxtype, MappedType) put($typemap(jboxtype, KeyType) key, - $typemap(jboxtype, MappedType) value) { + public $typemap(jboxtype, MappedType) put($typemap(jboxtype, KeyType) key, $typemap(jboxtype, MappedType) value) { Iterator itr = find(($typemap(jboxtype, KeyType)) key); if (itr.isNot(end())) { $typemap(jboxtype, MappedType) oldValue = itr.getValue(); diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i index 3b926b0e6..05b72f409 100644 --- a/Lib/java/std_unordered_map.i +++ b/Lib/java/std_unordered_map.i @@ -78,8 +78,7 @@ template class unordered_map { return null; } - public $typemap(jboxtype, MappedType) put($typemap(jboxtype, KeyType) key, - $typemap(jboxtype, MappedType) value) { + public $typemap(jboxtype, MappedType) put($typemap(jboxtype, KeyType) key, $typemap(jboxtype, MappedType) value) { Iterator itr = find(($typemap(jboxtype, KeyType)) key); if (itr.isNot(end())) { $typemap(jboxtype, MappedType) oldValue = itr.getValue(); From 82d163207140935919faaa73a7fffa0db1c5888e Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Tue, 12 Feb 2019 06:36:01 +0000 Subject: [PATCH 12/26] Combine duplicate unordered_set unordered_map testcases Merge cpp11_li_std_unordered_map into cpp11_std_unordered_map Merge cpp11_li_std_unordered_set into cpp11_std_unordered_set --- Examples/test-suite/cpp11_li_std_unordered_map.i | 11 ----------- Examples/test-suite/cpp11_li_std_unordered_set.i | 10 ---------- Examples/test-suite/cpp11_std_unordered_map.i | 2 ++ Examples/test-suite/cpp11_std_unordered_set.i | 2 ++ Examples/test-suite/java/Makefile.in | 4 ++-- ..._runme.java => cpp11_std_unordered_map_runme.java} | 10 +++++----- ..._runme.java => cpp11_std_unordered_set_runme.java} | 10 +++++----- 7 files changed, 16 insertions(+), 33 deletions(-) delete mode 100644 Examples/test-suite/cpp11_li_std_unordered_map.i delete mode 100644 Examples/test-suite/cpp11_li_std_unordered_set.i rename Examples/test-suite/java/{cpp11_li_std_unordered_map_runme.java => cpp11_std_unordered_map_runme.java} (92%) rename Examples/test-suite/java/{cpp11_li_std_unordered_set_runme.java => cpp11_std_unordered_set_runme.java} (89%) diff --git a/Examples/test-suite/cpp11_li_std_unordered_map.i b/Examples/test-suite/cpp11_li_std_unordered_map.i deleted file mode 100644 index 5f40e76fd..000000000 --- a/Examples/test-suite/cpp11_li_std_unordered_map.i +++ /dev/null @@ -1,11 +0,0 @@ -/* - * A test of unordered_map containers. - */ - -%module cpp11_li_std_unordered_map - -%include -%include - -%template(IntIntUnorderedMap) std::unordered_map; -%template(StringIntUnorderedMap) std::unordered_map; diff --git a/Examples/test-suite/cpp11_li_std_unordered_set.i b/Examples/test-suite/cpp11_li_std_unordered_set.i deleted file mode 100644 index e9711ce60..000000000 --- a/Examples/test-suite/cpp11_li_std_unordered_set.i +++ /dev/null @@ -1,10 +0,0 @@ -/* - * A test of unordered_set containers. - */ - -%module cpp11_li_std_unordered_set - -%include -%include - -%template(StringUnorderedSet) std::unordered_set; diff --git a/Examples/test-suite/cpp11_std_unordered_map.i b/Examples/test-suite/cpp11_std_unordered_map.i index 56c4a5248..b11d8f275 100644 --- a/Examples/test-suite/cpp11_std_unordered_map.i +++ b/Examples/test-suite/cpp11_std_unordered_map.i @@ -1,5 +1,7 @@ %module cpp11_std_unordered_map +%include %include %template(UnorderedMapIntInt) std::unordered_map; +%template(UnorderedMapStringInt) std::unordered_map; diff --git a/Examples/test-suite/cpp11_std_unordered_set.i b/Examples/test-suite/cpp11_std_unordered_set.i index f5652cb88..c2b8174bb 100644 --- a/Examples/test-suite/cpp11_std_unordered_set.i +++ b/Examples/test-suite/cpp11_std_unordered_set.i @@ -1,5 +1,7 @@ %module cpp11_std_unordered_set +%include %include %template(UnorderedSetInt) std::unordered_set; +%template(UnorderedSetString) std::unordered_set; diff --git a/Examples/test-suite/java/Makefile.in b/Examples/test-suite/java/Makefile.in index 3323f8a9c..2e788fa07 100644 --- a/Examples/test-suite/java/Makefile.in +++ b/Examples/test-suite/java/Makefile.in @@ -53,9 +53,9 @@ CPP11_TEST_CASES = \ cpp11_shared_ptr_nullptr_in_containers \ cpp11_shared_ptr_overload \ cpp11_shared_ptr_upcast \ + cpp11_std_unordered_map \ + cpp11_std_unordered_set \ cpp11_strongly_typed_enumerations_simple \ - cpp11_li_std_unordered_map \ - cpp11_li_std_unordered_set \ DOXYGEN_TEST_CASES := \ doxygen_parsing_enums_simple \ diff --git a/Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java b/Examples/test-suite/java/cpp11_std_unordered_map_runme.java similarity index 92% rename from Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java rename to Examples/test-suite/java/cpp11_std_unordered_map_runme.java index bb85eeadd..79f683378 100644 --- a/Examples/test-suite/java/cpp11_li_std_unordered_map_runme.java +++ b/Examples/test-suite/java/cpp11_std_unordered_map_runme.java @@ -1,10 +1,10 @@ -import cpp11_li_std_unordered_map.*; +import cpp11_std_unordered_map.*; -public class cpp11_li_std_unordered_map_runme { +public class cpp11_std_unordered_map_runme { static { try { - System.loadLibrary("cpp11_li_std_unordered_map"); + System.loadLibrary("cpp11_std_unordered_map"); } catch (UnsatisfiedLinkError e) { System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); System.exit(1); @@ -20,8 +20,8 @@ public class cpp11_li_std_unordered_map_runme { public static void main(String argv[]) throws Throwable { - java.util.AbstractMap sim = new StringIntUnorderedMap(); - java.util.AbstractMap iim = new IntIntUnorderedMap(); + java.util.AbstractMap sim = new UnorderedMapStringInt(); + java.util.AbstractMap iim = new UnorderedMapIntInt(); checkThat(sim.isEmpty()); checkThat(iim.isEmpty()); diff --git a/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java b/Examples/test-suite/java/cpp11_std_unordered_set_runme.java similarity index 89% rename from Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java rename to Examples/test-suite/java/cpp11_std_unordered_set_runme.java index dddf00307..9d64ab240 100644 --- a/Examples/test-suite/java/cpp11_li_std_unordered_set_runme.java +++ b/Examples/test-suite/java/cpp11_std_unordered_set_runme.java @@ -1,10 +1,10 @@ -import cpp11_li_std_unordered_set.*; +import cpp11_std_unordered_set.*; -public class cpp11_li_std_unordered_set_runme { +public class cpp11_std_unordered_set_runme { static { try { - System.loadLibrary("cpp11_li_std_unordered_set"); + System.loadLibrary("cpp11_std_unordered_set"); } catch (UnsatisfiedLinkError e) { System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); System.exit(1); @@ -20,7 +20,7 @@ public class cpp11_li_std_unordered_set_runme { public static void main(String argv[]) throws Throwable { - java.util.AbstractSet ss = new StringUnorderedSet(); + java.util.AbstractSet ss = new UnorderedSetString(); checkThat(ss.isEmpty()); checkThat(!ss.contains("key")); @@ -63,7 +63,7 @@ public class cpp11_li_std_unordered_set_runme { checkThat(ss.containsAll(found)); checkThat(found.containsAll(ss)); - java.util.AbstractSet ss2 = new StringUnorderedSet(ss); + java.util.AbstractSet ss2 = new UnorderedSetString(ss); checkThat(ss2.containsAll(ss)); checkThat(ss.containsAll(ss2)); From e83e14a15e67205ba7d5b7bf32a0cababaf1569b Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Tue, 12 Feb 2019 07:15:51 +0000 Subject: [PATCH 13/26] Add missing typedefs to Java STL containers --- Lib/java/std_map.i | 5 +++++ Lib/java/std_set.i | 4 ++++ Lib/java/std_unordered_map.i | 5 +++++ Lib/java/std_unordered_set.i | 4 ++++ 4 files changed, 18 insertions(+) diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index b177f9021..e44a7e97a 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -146,7 +146,12 @@ template typedef ptrdiff_t difference_type; typedef KeyType key_type; typedef MappedType mapped_type; + typedef std::pair< const KeyType, MappedType > value_type; typedef Compare key_compare; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; map(); map(const map&); diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i index 020ab67f7..018d056cc 100644 --- a/Lib/java/std_set.i +++ b/Lib/java/std_set.i @@ -154,6 +154,10 @@ class set { typedef T value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; set(); set(const set&); diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i index 05b72f409..86992479e 100644 --- a/Lib/java/std_unordered_map.i +++ b/Lib/java/std_unordered_map.i @@ -146,6 +146,11 @@ template class unordered_map { typedef ptrdiff_t difference_type; typedef KeyType key_type; typedef MappedType mapped_type; + typedef std::pair< const KeyType, MappedType > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; unordered_map(); unordered_map(const unordered_map&); diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i index 13d1fa4f9..3cbdca639 100644 --- a/Lib/java/std_unordered_set.i +++ b/Lib/java/std_unordered_set.i @@ -154,6 +154,10 @@ class unordered_set { typedef T value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; unordered_set(); unordered_set(const unordered_set&); From 68e86614ff6e02396533228932b0eb87d34f324c Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Tue, 12 Feb 2019 18:46:05 +0000 Subject: [PATCH 14/26] Create a consistent stl.i library file Same file now for all languages except R which is still missing std_map.i. Recent Java changes adding in std_set.i removed. --- Lib/csharp/stl.i | 2 -- Lib/d/stl.i | 2 -- Lib/go/stl.i | 1 + Lib/guile/stl.i | 2 -- Lib/java/stl.i | 6 +++--- Lib/mzscheme/stl.i | 3 +-- Lib/ocaml/stl.i | 2 -- Lib/octave/stl.i | 6 +++++- Lib/perl5/stl.i | 3 +-- Lib/php/stl.i | 2 -- Lib/python/stl.i | 5 ++++- Lib/r/stl.i | 15 +++++++-------- Lib/ruby/stl.i | 2 -- Lib/scilab/stl.i | 6 +++++- Lib/tcl/stl.i | 1 - 15 files changed, 27 insertions(+), 31 deletions(-) diff --git a/Lib/csharp/stl.i b/Lib/csharp/stl.i index 9d2e91eee..04f86014f 100644 --- a/Lib/csharp/stl.i +++ b/Lib/csharp/stl.i @@ -1,7 +1,5 @@ /* ----------------------------------------------------------------------------- * stl.i - * - * Initial STL definition. extended as needed in each language * ----------------------------------------------------------------------------- */ %include diff --git a/Lib/d/stl.i b/Lib/d/stl.i index 9d2e91eee..04f86014f 100644 --- a/Lib/d/stl.i +++ b/Lib/d/stl.i @@ -1,7 +1,5 @@ /* ----------------------------------------------------------------------------- * stl.i - * - * Initial STL definition. extended as needed in each language * ----------------------------------------------------------------------------- */ %include diff --git a/Lib/go/stl.i b/Lib/go/stl.i index 38aba67b8..04f86014f 100644 --- a/Lib/go/stl.i +++ b/Lib/go/stl.i @@ -7,3 +7,4 @@ %include %include %include + diff --git a/Lib/guile/stl.i b/Lib/guile/stl.i index 9d2e91eee..04f86014f 100644 --- a/Lib/guile/stl.i +++ b/Lib/guile/stl.i @@ -1,7 +1,5 @@ /* ----------------------------------------------------------------------------- * stl.i - * - * Initial STL definition. extended as needed in each language * ----------------------------------------------------------------------------- */ %include diff --git a/Lib/java/stl.i b/Lib/java/stl.i index a04adf7b6..04f86014f 100644 --- a/Lib/java/stl.i +++ b/Lib/java/stl.i @@ -3,8 +3,8 @@ * ----------------------------------------------------------------------------- */ %include -%include -%include -%include %include %include +%include +%include + diff --git a/Lib/mzscheme/stl.i b/Lib/mzscheme/stl.i index b19eae58b..04f86014f 100644 --- a/Lib/mzscheme/stl.i +++ b/Lib/mzscheme/stl.i @@ -1,8 +1,7 @@ /* ----------------------------------------------------------------------------- * stl.i - * - * Initial STL definition. extended as needed in each language * ----------------------------------------------------------------------------- */ + %include %include %include diff --git a/Lib/ocaml/stl.i b/Lib/ocaml/stl.i index 9d2e91eee..04f86014f 100644 --- a/Lib/ocaml/stl.i +++ b/Lib/ocaml/stl.i @@ -1,7 +1,5 @@ /* ----------------------------------------------------------------------------- * stl.i - * - * Initial STL definition. extended as needed in each language * ----------------------------------------------------------------------------- */ %include diff --git a/Lib/octave/stl.i b/Lib/octave/stl.i index b29f7d84d..04f86014f 100644 --- a/Lib/octave/stl.i +++ b/Lib/octave/stl.i @@ -1,6 +1,10 @@ -/* initial STL definition. extended as needed in each language */ +/* ----------------------------------------------------------------------------- + * stl.i + * ----------------------------------------------------------------------------- */ + %include %include %include %include %include + diff --git a/Lib/perl5/stl.i b/Lib/perl5/stl.i index b19eae58b..04f86014f 100644 --- a/Lib/perl5/stl.i +++ b/Lib/perl5/stl.i @@ -1,8 +1,7 @@ /* ----------------------------------------------------------------------------- * stl.i - * - * Initial STL definition. extended as needed in each language * ----------------------------------------------------------------------------- */ + %include %include %include diff --git a/Lib/php/stl.i b/Lib/php/stl.i index 9d2e91eee..04f86014f 100644 --- a/Lib/php/stl.i +++ b/Lib/php/stl.i @@ -1,7 +1,5 @@ /* ----------------------------------------------------------------------------- * stl.i - * - * Initial STL definition. extended as needed in each language * ----------------------------------------------------------------------------- */ %include diff --git a/Lib/python/stl.i b/Lib/python/stl.i index a3566db5c..04f86014f 100644 --- a/Lib/python/stl.i +++ b/Lib/python/stl.i @@ -1,4 +1,7 @@ -/* initial STL definition. extended as needed in each language */ +/* ----------------------------------------------------------------------------- + * stl.i + * ----------------------------------------------------------------------------- */ + %include %include %include diff --git a/Lib/r/stl.i b/Lib/r/stl.i index 37e2ccbf4..91da6a2bf 100644 --- a/Lib/r/stl.i +++ b/Lib/r/stl.i @@ -1,10 +1,9 @@ -/* initial STL definition. extended as needed in each language */ -%include std_common.i -%include std_vector.i -%include std_pair.i -%include std_string.i - - - +/* ----------------------------------------------------------------------------- + * stl.i + * ----------------------------------------------------------------------------- */ +%include +%include +%include +%include diff --git a/Lib/ruby/stl.i b/Lib/ruby/stl.i index 9d2e91eee..04f86014f 100644 --- a/Lib/ruby/stl.i +++ b/Lib/ruby/stl.i @@ -1,7 +1,5 @@ /* ----------------------------------------------------------------------------- * stl.i - * - * Initial STL definition. extended as needed in each language * ----------------------------------------------------------------------------- */ %include diff --git a/Lib/scilab/stl.i b/Lib/scilab/stl.i index b29f7d84d..04f86014f 100644 --- a/Lib/scilab/stl.i +++ b/Lib/scilab/stl.i @@ -1,6 +1,10 @@ -/* initial STL definition. extended as needed in each language */ +/* ----------------------------------------------------------------------------- + * stl.i + * ----------------------------------------------------------------------------- */ + %include %include %include %include %include + diff --git a/Lib/tcl/stl.i b/Lib/tcl/stl.i index 40c7584ec..04f86014f 100644 --- a/Lib/tcl/stl.i +++ b/Lib/tcl/stl.i @@ -2,7 +2,6 @@ * stl.i * ----------------------------------------------------------------------------- */ -/* initial STL definition. extended as needed in each language */ %include %include %include From 6d0c495fd042a313e0a8d6a9d36209b92b9bf42b Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Tue, 12 Feb 2019 22:04:58 +0000 Subject: [PATCH 15/26] Add missing parameter names in STL container wrappers Mostly in STL copy constructors. Best to have parameter names as they make their way into the wrappers in some target languages. --- Lib/allegrocl/std_list.i | 2 +- Lib/d/std_map.i | 2 +- Lib/go/std_map.i | 2 +- Lib/guile/std_map.i | 8 ++++---- Lib/guile/std_vector.i | 4 ++-- Lib/java/std_map.i | 4 ++-- Lib/java/std_set.i | 2 +- Lib/java/std_unordered_map.i | 4 ++-- Lib/java/std_unordered_set.i | 2 +- Lib/javascript/jsc/std_map.i | 2 +- Lib/javascript/v8/std_map.i | 2 +- Lib/lua/std_map.i | 2 +- Lib/lua/std_pair.i | 2 +- Lib/lua/std_string.i | 2 -- Lib/lua/std_vector.i | 2 +- Lib/mzscheme/std_map.i | 8 ++++---- Lib/mzscheme/std_vector.i | 4 ++-- Lib/ocaml/std_list.i | 2 +- Lib/ocaml/std_map.i | 2 +- Lib/ocaml/std_vector.i | 2 +- Lib/octave/std_deque.i | 2 +- Lib/octave/std_list.i | 2 +- Lib/perl5/std_list.i | 4 ++-- Lib/perl5/std_map.i | 2 +- Lib/perl5/std_vector.i | 6 +++--- Lib/php/std_map.i | 2 +- Lib/python/std_deque.i | 2 +- Lib/python/std_list.i | 2 +- Lib/ruby/rubycontainer.swg | 4 ++-- Lib/ruby/rubycontainer_extended.swg | 2 +- Lib/ruby/std_deque.i | 2 +- Lib/ruby/std_list.i | 2 +- Lib/ruby/std_queue.i | 2 +- Lib/ruby/std_stack.i | 2 +- Lib/scilab/std_map.i | 2 +- Lib/std/std_alloc.i | 4 ++-- Lib/std/std_container.i | 2 +- Lib/std/std_ios.i | 8 ++++---- Lib/std/std_iostream.i | 6 +++--- Lib/std/std_map.i | 2 +- Lib/std/std_multimap.i | 2 +- Lib/std/std_multiset.i | 2 +- Lib/std/std_queue.i | 4 ++-- Lib/std/std_set.i | 4 ++-- Lib/std/std_stack.i | 4 ++-- Lib/std/std_streambuf.i | 2 +- Lib/std/std_unordered_set.i | 2 +- Lib/tcl/std_map.i | 2 +- Lib/tcl/std_vector.i | 4 ++-- 49 files changed, 72 insertions(+), 74 deletions(-) diff --git a/Lib/allegrocl/std_list.i b/Lib/allegrocl/std_list.i index 4e260897f..332691de1 100644 --- a/Lib/allegrocl/std_list.i +++ b/Lib/allegrocl/std_list.i @@ -36,7 +36,7 @@ namespace std{ list(); list(unsigned int size, const T& value = T()); - list(const list &); + list(const list &other); ~list(); void assign(unsigned int n, const T& value); diff --git a/Lib/d/std_map.i b/Lib/d/std_map.i index 968def214..b7da364cc 100644 --- a/Lib/d/std_map.i +++ b/Lib/d/std_map.i @@ -24,7 +24,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/go/std_map.i b/Lib/go/std_map.i index f514cf743..3077d157f 100644 --- a/Lib/go/std_map.i +++ b/Lib/go/std_map.i @@ -28,7 +28,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/guile/std_map.i b/Lib/guile/std_map.i index ca9883688..4b8dd67c2 100644 --- a/Lib/guile/std_map.i +++ b/Lib/guile/std_map.i @@ -219,7 +219,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C> &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; @@ -435,7 +435,7 @@ namespace std { %rename("has-key?") has_key; public: map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; @@ -641,7 +641,7 @@ namespace std { %rename("has-key?") has_key; public: map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; @@ -849,7 +849,7 @@ namespace std { %rename("has-key?") has_key; public: map(); - map(const map< K, T, C> &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/guile/std_vector.i b/Lib/guile/std_vector.i index d7a7140c6..c144f879c 100644 --- a/Lib/guile/std_vector.i +++ b/Lib/guile/std_vector.i @@ -189,7 +189,7 @@ namespace std { public: vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector&); + vector(const vector& other); %rename(length) size; unsigned int size() const; %rename("empty?") empty; @@ -353,7 +353,7 @@ namespace std { public: vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector&); + vector(const vector& other); %rename(length) size; unsigned int size() const; %rename("empty?") empty; diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index e44a7e97a..0b0041fb8 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -154,7 +154,7 @@ template typedef const value_type& const_reference; map(); - map(const map&); + map(const map& other); struct iterator { %typemap(javaclassmodifiers) iterator "protected class" @@ -185,7 +185,7 @@ template %rename(isEmpty) empty; bool empty() const; void clear(); - iterator find(const KeyType&); + iterator find(const KeyType& key); iterator begin(); iterator end(); %extend { diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i index 018d056cc..4453d90bd 100644 --- a/Lib/java/std_set.i +++ b/Lib/java/std_set.i @@ -160,7 +160,7 @@ class set { typedef const value_type& const_reference; set(); - set(const set&); + set(const set& other); %rename(isEmpty) empty; bool empty() const; diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i index 86992479e..eecdf0bc4 100644 --- a/Lib/java/std_unordered_map.i +++ b/Lib/java/std_unordered_map.i @@ -153,7 +153,7 @@ template class unordered_map { typedef const value_type& const_reference; unordered_map(); - unordered_map(const unordered_map&); + unordered_map(const unordered_map& other); struct iterator { %typemap(javaclassmodifiers) iterator "protected class" @@ -184,7 +184,7 @@ template class unordered_map { %rename(isEmpty) empty; bool empty() const; void clear(); - iterator find(const KeyType&); + iterator find(const KeyType& key); iterator begin(); iterator end(); %extend { diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i index 3cbdca639..06c7a1123 100644 --- a/Lib/java/std_unordered_set.i +++ b/Lib/java/std_unordered_set.i @@ -160,7 +160,7 @@ class unordered_set { typedef const value_type& const_reference; unordered_set(); - unordered_set(const unordered_set&); + unordered_set(const unordered_set& other); %rename(isEmpty) empty; bool empty() const; diff --git a/Lib/javascript/jsc/std_map.i b/Lib/javascript/jsc/std_map.i index 903f77aa5..cc9474abc 100644 --- a/Lib/javascript/jsc/std_map.i +++ b/Lib/javascript/jsc/std_map.i @@ -28,7 +28,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/javascript/v8/std_map.i b/Lib/javascript/v8/std_map.i index 903f77aa5..cc9474abc 100644 --- a/Lib/javascript/v8/std_map.i +++ b/Lib/javascript/v8/std_map.i @@ -28,7 +28,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/lua/std_map.i b/Lib/lua/std_map.i index 8a203e133..3077d157f 100644 --- a/Lib/lua/std_map.i +++ b/Lib/lua/std_map.i @@ -28,7 +28,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C> &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/lua/std_pair.i b/Lib/lua/std_pair.i index 06728533b..eee365c82 100644 --- a/Lib/lua/std_pair.i +++ b/Lib/lua/std_pair.i @@ -37,6 +37,6 @@ namespace std { }; template - pair make_pair(const T&,const U&); + pair make_pair(const T& t,const U& u); } diff --git a/Lib/lua/std_string.i b/Lib/lua/std_string.i index e9f326b52..b95a8a4a2 100644 --- a/Lib/lua/std_string.i +++ b/Lib/lua/std_string.i @@ -109,7 +109,6 @@ as this is overloaded by the const char* version public: string(); string(const char*); - //string(const string&); unsigned int size() const; unsigned int length() const; bool empty() const; @@ -119,7 +118,6 @@ as this is overloaded by the const char* version // assign does not return a copy of this object // (no point in a scripting language) void assign(const char*); - //void assign(const string&); // no support for all the other features // it's probably better to do it in lua }; diff --git a/Lib/lua/std_vector.i b/Lib/lua/std_vector.i index a4ea978db..3199a9dab 100644 --- a/Lib/lua/std_vector.i +++ b/Lib/lua/std_vector.i @@ -27,7 +27,7 @@ namespace std { public: vector(); vector(unsigned int); - vector(const vector&); + vector(const vector& other); vector(unsigned int,T); unsigned int size() const; unsigned int max_size() const; diff --git a/Lib/mzscheme/std_map.i b/Lib/mzscheme/std_map.i index 6a0cb2d36..68c7f7fb1 100644 --- a/Lib/mzscheme/std_map.i +++ b/Lib/mzscheme/std_map.i @@ -222,7 +222,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; @@ -442,7 +442,7 @@ namespace std { %rename("has-key?") has_key; public: map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; @@ -654,7 +654,7 @@ namespace std { %rename("has-key?") has_key; public: map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; @@ -866,7 +866,7 @@ namespace std { %rename("has-key?") has_key; public: map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/mzscheme/std_vector.i b/Lib/mzscheme/std_vector.i index 22e1fa96b..9fa2d5497 100644 --- a/Lib/mzscheme/std_vector.i +++ b/Lib/mzscheme/std_vector.i @@ -191,7 +191,7 @@ namespace std { public: vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector&); + vector(const vector& other); %rename(length) size; unsigned int size() const; %rename("empty?") empty; @@ -367,7 +367,7 @@ namespace std { public: vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector&); + vector(const vector& other); %rename(length) size; unsigned int size() const; %rename("empty?") empty; diff --git a/Lib/ocaml/std_list.i b/Lib/ocaml/std_list.i index 06181cca8..cb648d711 100644 --- a/Lib/ocaml/std_list.i +++ b/Lib/ocaml/std_list.i @@ -25,7 +25,7 @@ namespace std{ list(); list(unsigned int size, const T& value = T()); - list(const list &); + list(const list& other); ~list(); void assign(unsigned int n, const T& value); diff --git a/Lib/ocaml/std_map.i b/Lib/ocaml/std_map.i index 91756bec0..b50bc7fc0 100644 --- a/Lib/ocaml/std_map.i +++ b/Lib/ocaml/std_map.i @@ -27,7 +27,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/ocaml/std_vector.i b/Lib/ocaml/std_vector.i index 6f82058b5..053b645f0 100644 --- a/Lib/ocaml/std_vector.i +++ b/Lib/ocaml/std_vector.i @@ -43,7 +43,7 @@ namespace std { public: vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector&); + vector(const vector& other); unsigned int size() const; bool empty() const; void clear(); diff --git a/Lib/octave/std_deque.i b/Lib/octave/std_deque.i index 6866a610f..c40cfee12 100644 --- a/Lib/octave/std_deque.i +++ b/Lib/octave/std_deque.i @@ -12,7 +12,7 @@ template struct traits_from > { - static octave_value from(const std::deque & vec) { + static octave_value from(const std::deque& vec) { return traits_from_stdseq >::from(vec); } }; diff --git a/Lib/octave/std_list.i b/Lib/octave/std_list.i index 1421efaee..35f6c1321 100644 --- a/Lib/octave/std_list.i +++ b/Lib/octave/std_list.i @@ -12,7 +12,7 @@ template struct traits_from > { - static octave_value *from(const std::list & vec) { + static octave_value *from(const std::list& vec) { return traits_from_stdseq >::from(vec); } }; diff --git a/Lib/perl5/std_list.i b/Lib/perl5/std_list.i index cd5a61120..8e2945fba 100644 --- a/Lib/perl5/std_list.i +++ b/Lib/perl5/std_list.i @@ -193,7 +193,7 @@ namespace std { typedef const value_type& const_reference; list(); - list(const list &); + list(const list& other); unsigned int size() const; bool empty() const; @@ -346,7 +346,7 @@ namespace std { typedef const value_type& const_reference; list(); - list(const list &); + list(const list& other); unsigned int size() const; bool empty() const; diff --git a/Lib/perl5/std_map.i b/Lib/perl5/std_map.i index ae7c26601..fe9b6f3f1 100644 --- a/Lib/perl5/std_map.i +++ b/Lib/perl5/std_map.i @@ -28,7 +28,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/perl5/std_vector.i b/Lib/perl5/std_vector.i index ec8449464..adfe95df6 100644 --- a/Lib/perl5/std_vector.i +++ b/Lib/perl5/std_vector.i @@ -185,7 +185,7 @@ namespace std { typedef const value_type& const_reference; vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector &); + vector(const vector& other); unsigned int size() const; bool empty() const; @@ -357,7 +357,7 @@ namespace std { typedef const value_type& const_reference; vector(unsigned int size = 0); vector(unsigned int size, T *value); - vector(const vector &); + vector(const vector& other); unsigned int size() const; bool empty() const; @@ -528,7 +528,7 @@ namespace std { typedef const value_type& const_reference; vector(unsigned int size = 0); vector(unsigned int size, T value); - vector(const vector &); + vector(const vector& other); unsigned int size() const; bool empty() const; diff --git a/Lib/php/std_map.i b/Lib/php/std_map.i index 020c20153..4d93fa144 100644 --- a/Lib/php/std_map.i +++ b/Lib/php/std_map.i @@ -28,7 +28,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; void clear(); diff --git a/Lib/python/std_deque.i b/Lib/python/std_deque.i index b19375633..d9a174706 100644 --- a/Lib/python/std_deque.i +++ b/Lib/python/std_deque.i @@ -14,7 +14,7 @@ template struct traits_from > { - static PyObject *from(const std::deque & vec) { + static PyObject *from(const std::deque& vec) { return traits_from_stdseq >::from(vec); } }; diff --git a/Lib/python/std_list.i b/Lib/python/std_list.i index baf66d914..24d274b42 100644 --- a/Lib/python/std_list.i +++ b/Lib/python/std_list.i @@ -14,7 +14,7 @@ template struct traits_from > { - static PyObject *from(const std::list & vec) { + static PyObject *from(const std::list& vec) { return traits_from_stdseq >::from(vec); } }; diff --git a/Lib/ruby/rubycontainer.swg b/Lib/ruby/rubycontainer.swg index 4d0163f51..e8830a715 100644 --- a/Lib/ruby/rubycontainer.swg +++ b/Lib/ruby/rubycontainer.swg @@ -943,7 +943,7 @@ namespace swig } } - catch( const std::invalid_argument & ) + catch(const std::invalid_argument &) { rb_raise( rb_eArgError, "%s", Ruby_Format_TypeError( "", @@ -970,7 +970,7 @@ namespace swig Sequence::value_type val = swig::as( elem ); $self->insert( start, val ); } - catch( const std::invalid_argument & ) + catch(const std::invalid_argument &) { rb_raise( rb_eArgError, "%s", Ruby_Format_TypeError( "", diff --git a/Lib/ruby/rubycontainer_extended.swg b/Lib/ruby/rubycontainer_extended.swg index 7514ba2c8..663dddb8c 100644 --- a/Lib/ruby/rubycontainer_extended.swg +++ b/Lib/ruby/rubycontainer_extended.swg @@ -69,7 +69,7 @@ *i = swig::as< Type >( r ); } } - catch ( const std::invalid_argument& ) + catch (const std::invalid_argument&) { rb_raise(rb_eTypeError, "Yield block did not return a valid element for " "Container"); diff --git a/Lib/ruby/std_deque.i b/Lib/ruby/std_deque.i index 38048aff7..b70f34ee3 100644 --- a/Lib/ruby/std_deque.i +++ b/Lib/ruby/std_deque.i @@ -14,7 +14,7 @@ template struct traits_from > { - static VALUE from(const std::deque & vec) { + static VALUE from(const std::deque& vec) { return traits_from_stdseq >::from(vec); } }; diff --git a/Lib/ruby/std_list.i b/Lib/ruby/std_list.i index 5f179cc69..b0b4928e4 100644 --- a/Lib/ruby/std_list.i +++ b/Lib/ruby/std_list.i @@ -14,7 +14,7 @@ template struct traits_from > { - static VALUE from(const std::list & vec) { + static VALUE from(const std::list& vec) { return traits_from_stdseq >::from(vec); } }; diff --git a/Lib/ruby/std_queue.i b/Lib/ruby/std_queue.i index a12936775..2a16d9cfd 100644 --- a/Lib/ruby/std_queue.i +++ b/Lib/ruby/std_queue.i @@ -14,7 +14,7 @@ template struct traits_from > { - static VALUE from(const std::queue & vec) { + static VALUE from(const std::queue& vec) { return traits_from_stdseq >::from(vec); } }; diff --git a/Lib/ruby/std_stack.i b/Lib/ruby/std_stack.i index 600c81c96..7df48ef1b 100644 --- a/Lib/ruby/std_stack.i +++ b/Lib/ruby/std_stack.i @@ -14,7 +14,7 @@ template struct traits_from > { - static VALUE from(const std::stack & vec) { + static VALUE from(const std::stack& vec) { return traits_from_stdseq >::from(vec); } }; diff --git a/Lib/scilab/std_map.i b/Lib/scilab/std_map.i index 0255e2f6a..aea1c7141 100644 --- a/Lib/scilab/std_map.i +++ b/Lib/scilab/std_map.i @@ -23,7 +23,7 @@ namespace std { // add typemaps here public: map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/std/std_alloc.i b/Lib/std/std_alloc.i index 44dc8dc3e..e460dc3ea 100644 --- a/Lib/std/std_alloc.i +++ b/Lib/std/std_alloc.i @@ -31,9 +31,9 @@ namespace std allocator() throw(); - allocator(const allocator&) throw(); + allocator(const allocator& other) throw(); template - allocator(const allocator<_Tp1>&) throw(); + allocator(const allocator<_Tp1>& other) throw(); ~allocator() throw(); diff --git a/Lib/std/std_container.i b/Lib/std/std_container.i index 000163f1e..570dfde48 100644 --- a/Lib/std/std_container.i +++ b/Lib/std/std_container.i @@ -11,7 +11,7 @@ %define %std_container_methods_non_resizable(container...) container(); - container(const container&); + container(const container& other); bool empty() const; size_type size() const; diff --git a/Lib/std/std_ios.i b/Lib/std/std_ios.i index db83c7abf..7c62ed690 100644 --- a/Lib/std/std_ios.i +++ b/Lib/std/std_ios.i @@ -153,10 +153,10 @@ namespace std { //50. Copy constructor and assignment operator of ios_base private: - ios_base(const ios_base&); + ios_base(const ios_base& other); ios_base& - operator=(const ios_base&); + operator=(const ios_base& other); }; template > @@ -242,10 +242,10 @@ namespace std { // 27.4.5.1 basic_ios constructors basic_ios(); private: - basic_ios(const basic_ios&); + basic_ios(const basic_ios& other); basic_ios& - operator=(const basic_ios&); + operator=(const basic_ios& other); }; } diff --git a/Lib/std/std_iostream.i b/Lib/std/std_iostream.i index 7a33afe39..38a22963f 100644 --- a/Lib/std/std_iostream.i +++ b/Lib/std/std_iostream.i @@ -306,15 +306,15 @@ namespace std template > std::basic_ostream<_CharT, _Traits>& - endl(std::basic_ostream<_CharT, _Traits>&); + endl(std::basic_ostream<_CharT, _Traits>& value); template > std::basic_ostream<_CharT, _Traits>& - ends(std::basic_ostream<_CharT, _Traits>&); + ends(std::basic_ostream<_CharT, _Traits>& value); template > std::basic_ostream<_CharT, _Traits>& - flush(std::basic_ostream<_CharT, _Traits>&); + flush(std::basic_ostream<_CharT, _Traits>& value); } namespace std { diff --git a/Lib/std/std_map.i b/Lib/std/std_map.i index 8043f924c..36c037860 100644 --- a/Lib/std/std_map.i +++ b/Lib/std/std_map.i @@ -113,7 +113,7 @@ namespace std { %typemap_traits_ptr(SWIG_TYPECHECK_MAP, std::map< _Key, _Tp, _Compare, _Alloc >); - map( const _Compare& ); + map(const _Compare& other); #ifdef %swig_map_methods // Add swig/language extra methods diff --git a/Lib/std/std_multimap.i b/Lib/std/std_multimap.i index 7aa949907..983a5d8fd 100644 --- a/Lib/std/std_multimap.i +++ b/Lib/std/std_multimap.i @@ -89,7 +89,7 @@ namespace std { %typemap_traits_ptr(SWIG_TYPECHECK_MULTIMAP, std::multimap< _Key, _Tp, _Compare, _Alloc >); - multimap( const _Compare& ); + multimap(const _Compare& other); #ifdef %swig_multimap_methods // Add swig/language extra methods diff --git a/Lib/std/std_multiset.i b/Lib/std/std_multiset.i index 1aa7ccce8..a1d0db813 100644 --- a/Lib/std/std_multiset.i +++ b/Lib/std/std_multiset.i @@ -71,7 +71,7 @@ namespace std { %typemap_traits_ptr(SWIG_TYPECHECK_MULTISET, std::multiset< _Key, _Compare, _Alloc >); - multiset( const _Compare& ); + multiset(const _Compare& other); #ifdef %swig_multiset_methods // Add swig/language extra methods diff --git a/Lib/std/std_queue.i b/Lib/std/std_queue.i index b2c8d8d33..51bb04473 100644 --- a/Lib/std/std_queue.i +++ b/Lib/std/std_queue.i @@ -13,14 +13,14 @@ %define %std_queue_methods(queue...) queue(); - queue( const _Sequence& ); + queue(const _Sequence& other); bool empty() const; size_type size() const; const value_type& front() const; const value_type& back() const; void pop(); - void push( const value_type& ); + void push(const value_type& value); %enddef %define %std_queue_methods_val(queue...) diff --git a/Lib/std/std_set.i b/Lib/std/std_set.i index 107a23c71..0e05aca40 100644 --- a/Lib/std/std_set.i +++ b/Lib/std/std_set.i @@ -8,7 +8,7 @@ // Set %define %std_set_methods_common(set...) set(); - set( const set& ); + set(const set& other); bool empty() const; size_type size() const; @@ -110,7 +110,7 @@ namespace std { %typemap_traits_ptr(SWIG_TYPECHECK_SET, std::set< _Key, _Compare, _Alloc >); - set( const _Compare& ); + set(const _Compare& other); #ifdef %swig_set_methods // Add swig/language extra methods diff --git a/Lib/std/std_stack.i b/Lib/std/std_stack.i index 5b624b571..ff714d099 100644 --- a/Lib/std/std_stack.i +++ b/Lib/std/std_stack.i @@ -13,13 +13,13 @@ %define %std_stack_methods(stack...) stack(); - stack( const _Sequence& ); + stack(const _Sequence& other); bool empty() const; size_type size() const; const value_type& top() const; void pop(); - void push( const value_type& ); + void push(const value_type& value); %enddef %define %std_stack_methods_val(stack...) diff --git a/Lib/std/std_streambuf.i b/Lib/std/std_streambuf.i index 7efb19c6c..e17249135 100644 --- a/Lib/std/std_streambuf.i +++ b/Lib/std/std_streambuf.i @@ -81,7 +81,7 @@ namespace std { basic_streambuf(); private: - basic_streambuf(const basic_streambuf&); + basic_streambuf(const basic_streambuf& other); }; } diff --git a/Lib/std/std_unordered_set.i b/Lib/std/std_unordered_set.i index 75e955c4b..133246da8 100644 --- a/Lib/std/std_unordered_set.i +++ b/Lib/std/std_unordered_set.i @@ -8,7 +8,7 @@ // Unordered Set %define %std_unordered_set_methods_common(unordered_set...) unordered_set(); - unordered_set( const unordered_set& ); + unordered_set(const unordered_set& other); bool empty() const; size_type size() const; diff --git a/Lib/tcl/std_map.i b/Lib/tcl/std_map.i index 96e7cae80..d59537922 100644 --- a/Lib/tcl/std_map.i +++ b/Lib/tcl/std_map.i @@ -27,7 +27,7 @@ namespace std { typedef K key_type; typedef T mapped_type; map(); - map(const map< K, T, C > &); + map(const map< K, T, C >& other); unsigned int size() const; bool empty() const; diff --git a/Lib/tcl/std_vector.i b/Lib/tcl/std_vector.i index 3fc0fd61d..71913f389 100644 --- a/Lib/tcl/std_vector.i +++ b/Lib/tcl/std_vector.i @@ -210,7 +210,7 @@ namespace std { public: vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector< T > &); + vector(const vector< T >& other); unsigned int size() const; bool empty() const; @@ -361,7 +361,7 @@ namespace std { public: vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector< T > &); + vector(const vector< T >& other); unsigned int size() const; bool empty() const; From 1f449973432d19a4c05987246dee372d1a503573 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Tue, 12 Feb 2019 22:30:43 +0000 Subject: [PATCH 16/26] rename std::array testcase --- Examples/test-suite/common.mk | 2 +- ...cpp11_li_std_array.i => cpp11_std_array.i} | 2 +- ...rray_runme.cs => cpp11_std_array_runme.cs} | 20 ++++++++--------- ..._runme.java => cpp11_std_array_runme.java} | 22 +++++++++---------- ...rray_runme.py => cpp11_std_array_runme.py} | 2 +- ...rray_runme.rb => cpp11_std_array_runme.rb} | 4 ++-- 6 files changed, 26 insertions(+), 26 deletions(-) rename Examples/test-suite/{cpp11_li_std_array.i => cpp11_std_array.i} (97%) rename Examples/test-suite/csharp/{cpp11_li_std_array_runme.cs => cpp11_std_array_runme.cs} (75%) rename Examples/test-suite/java/{cpp11_li_std_array_runme.java => cpp11_std_array_runme.java} (75%) rename Examples/test-suite/python/{cpp11_li_std_array_runme.py => cpp11_std_array_runme.py} (99%) rename Examples/test-suite/ruby/{cpp11_li_std_array_runme.rb => cpp11_std_array_runme.rb} (98%) diff --git a/Examples/test-suite/common.mk b/Examples/test-suite/common.mk index e7e3dd07b..944f682b0 100644 --- a/Examples/test-suite/common.mk +++ b/Examples/test-suite/common.mk @@ -575,7 +575,7 @@ CPP11_TEST_CASES += \ cpp11_initializer_list \ cpp11_initializer_list_extend \ cpp11_lambda_functions \ - cpp11_li_std_array \ + cpp11_std_array \ cpp11_noexcept \ cpp11_null_pointer_constant \ cpp11_raw_string_literals \ diff --git a/Examples/test-suite/cpp11_li_std_array.i b/Examples/test-suite/cpp11_std_array.i similarity index 97% rename from Examples/test-suite/cpp11_li_std_array.i rename to Examples/test-suite/cpp11_std_array.i index dedd6483a..3d4771551 100644 --- a/Examples/test-suite/cpp11_li_std_array.i +++ b/Examples/test-suite/cpp11_std_array.i @@ -1,4 +1,4 @@ -%module cpp11_li_std_array +%module cpp11_std_array #if defined(SWIGPYTHON) || defined(SWIGRUBY) || defined(SWIGJAVA) || defined(SWIGCSHARP) diff --git a/Examples/test-suite/csharp/cpp11_li_std_array_runme.cs b/Examples/test-suite/csharp/cpp11_std_array_runme.cs similarity index 75% rename from Examples/test-suite/csharp/cpp11_li_std_array_runme.cs rename to Examples/test-suite/csharp/cpp11_std_array_runme.cs index d0c956ad3..ee7c5ee24 100644 --- a/Examples/test-suite/csharp/cpp11_li_std_array_runme.cs +++ b/Examples/test-suite/csharp/cpp11_std_array_runme.cs @@ -1,8 +1,8 @@ // This test tests all the methods in the C# collection wrapper using System; -using cpp11_li_std_arrayNamespace; +using cpp11_std_arrayNamespace; -public class cpp11_li_std_array_runme +public class cpp11_std_array_runme { private static ArrayInt6 ToArray6(int[] a) { @@ -37,24 +37,24 @@ public class cpp11_li_std_array_runme compareContainers(ai, vals); // Check return - compareContainers(cpp11_li_std_array.arrayOutVal(), new int[] { -2, -1, 0, 0, 1, 2 }); - compareContainers(cpp11_li_std_array.arrayOutConstRef(), new int[] { -2, -1, 0, 0, 1, 2 }); - compareContainers(cpp11_li_std_array.arrayOutRef(), new int[] { -2, -1, 0, 0, 1, 2 }); - compareContainers(cpp11_li_std_array.arrayOutPtr(), new int[] { -2, -1, 0, 0, 1, 2 }); + compareContainers(cpp11_std_array.arrayOutVal(), new int[] { -2, -1, 0, 0, 1, 2 }); + compareContainers(cpp11_std_array.arrayOutConstRef(), new int[] { -2, -1, 0, 0, 1, 2 }); + compareContainers(cpp11_std_array.arrayOutRef(), new int[] { -2, -1, 0, 0, 1, 2 }); + compareContainers(cpp11_std_array.arrayOutPtr(), new int[] { -2, -1, 0, 0, 1, 2 }); // Check passing arguments - ai = cpp11_li_std_array.arrayInVal(ToArray6(new int[] { 9, 8, 7, 6, 5, 4 })); + ai = cpp11_std_array.arrayInVal(ToArray6(new int[] { 9, 8, 7, 6, 5, 4 })); compareContainers(ai, new int[] { 90, 80, 70, 60, 50, 40 }); - ai = cpp11_li_std_array.arrayInConstRef(ToArray6(new int[] { 9, 8, 7, 6, 5, 4 })); + ai = cpp11_std_array.arrayInConstRef(ToArray6(new int[] { 9, 8, 7, 6, 5, 4 })); compareContainers(ai, new int[] { 90, 80, 70, 60, 50, 40 }); ai = new ArrayInt6(ToArray6(new int[] { 9, 8, 7, 6, 5, 4 })); - cpp11_li_std_array.arrayInRef(ai); + cpp11_std_array.arrayInRef(ai); compareContainers(ai, new int[] { 90, 80, 70, 60, 50, 40 }); ai = new ArrayInt6(ToArray6(new int[] { 9, 8, 7, 6, 5, 4 })); - cpp11_li_std_array.arrayInPtr(ai); + cpp11_std_array.arrayInPtr(ai); compareContainers(ai, new int[] { 90, 80, 70, 60, 50, 40 }); // fill diff --git a/Examples/test-suite/java/cpp11_li_std_array_runme.java b/Examples/test-suite/java/cpp11_std_array_runme.java similarity index 75% rename from Examples/test-suite/java/cpp11_li_std_array_runme.java rename to Examples/test-suite/java/cpp11_std_array_runme.java index 2e2a20138..58fdc176b 100644 --- a/Examples/test-suite/java/cpp11_li_std_array_runme.java +++ b/Examples/test-suite/java/cpp11_std_array_runme.java @@ -1,10 +1,10 @@ -import cpp11_li_std_array.*; +import cpp11_std_array.*; -public class cpp11_li_std_array_runme { +public class cpp11_std_array_runme { static { try { - System.loadLibrary("cpp11_li_std_array"); + System.loadLibrary("cpp11_std_array"); } catch (UnsatisfiedLinkError e) { System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); System.exit(1); @@ -43,24 +43,24 @@ public class cpp11_li_std_array_runme { compareContainers(ai, vals); // Check return - compareContainers(cpp11_li_std_array.arrayOutVal(), new int[] {-2, -1, 0, 0, 1, 2}); - compareContainers(cpp11_li_std_array.arrayOutConstRef(), new int[] {-2, -1, 0, 0, 1, 2}); - compareContainers(cpp11_li_std_array.arrayOutRef(), new int[] {-2, -1, 0, 0, 1, 2}); - compareContainers(cpp11_li_std_array.arrayOutPtr(), new int[] {-2, -1, 0, 0, 1, 2}); + compareContainers(cpp11_std_array.arrayOutVal(), new int[] {-2, -1, 0, 0, 1, 2}); + compareContainers(cpp11_std_array.arrayOutConstRef(), new int[] {-2, -1, 0, 0, 1, 2}); + compareContainers(cpp11_std_array.arrayOutRef(), new int[] {-2, -1, 0, 0, 1, 2}); + compareContainers(cpp11_std_array.arrayOutPtr(), new int[] {-2, -1, 0, 0, 1, 2}); // Check passing arguments - ai = cpp11_li_std_array.arrayInVal(ToArray6(new int[] {9, 8, 7, 6, 5, 4})); + ai = cpp11_std_array.arrayInVal(ToArray6(new int[] {9, 8, 7, 6, 5, 4})); compareContainers(ai, new int[] {90, 80, 70, 60, 50, 40}); - ai = cpp11_li_std_array.arrayInConstRef(ToArray6(new int[] {9, 8, 7, 6, 5, 4})); + ai = cpp11_std_array.arrayInConstRef(ToArray6(new int[] {9, 8, 7, 6, 5, 4})); compareContainers(ai, new int[] {90, 80, 70, 60, 50, 40}); ai = new ArrayInt6(ToArray6(new int[] {9, 8, 7, 6, 5, 4})); - cpp11_li_std_array.arrayInRef(ai); + cpp11_std_array.arrayInRef(ai); compareContainers(ai, new int[] {90, 80, 70, 60, 50, 40}); ai = new ArrayInt6(ToArray6(new int[] {9, 8, 7, 6, 5, 4})); - cpp11_li_std_array.arrayInPtr(ai); + cpp11_std_array.arrayInPtr(ai); compareContainers(ai, new int[] {90, 80, 70, 60, 50, 40}); // fill diff --git a/Examples/test-suite/python/cpp11_li_std_array_runme.py b/Examples/test-suite/python/cpp11_std_array_runme.py similarity index 99% rename from Examples/test-suite/python/cpp11_li_std_array_runme.py rename to Examples/test-suite/python/cpp11_std_array_runme.py index 3b1ceb2f8..e5e7373dd 100644 --- a/Examples/test-suite/python/cpp11_li_std_array_runme.py +++ b/Examples/test-suite/python/cpp11_std_array_runme.py @@ -1,4 +1,4 @@ -from cpp11_li_std_array import * +from cpp11_std_array import * import sys diff --git a/Examples/test-suite/ruby/cpp11_li_std_array_runme.rb b/Examples/test-suite/ruby/cpp11_std_array_runme.rb similarity index 98% rename from Examples/test-suite/ruby/cpp11_li_std_array_runme.rb rename to Examples/test-suite/ruby/cpp11_std_array_runme.rb index 770f37c0f..13c5efb84 100644 --- a/Examples/test-suite/ruby/cpp11_li_std_array_runme.rb +++ b/Examples/test-suite/ruby/cpp11_std_array_runme.rb @@ -9,9 +9,9 @@ require 'swig_assert' -require 'cpp11_li_std_array' +require 'cpp11_std_array' -include Cpp11_li_std_array +include Cpp11_std_array def failed(a, b, msg) From 9dd33e6367b59f65cc1ca04d46a34fbf2f9e35f1 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Tue, 12 Feb 2019 22:52:43 +0000 Subject: [PATCH 17/26] Add missing typedefs to std::map --- Lib/csharp/std_map.i | 5 +++++ Lib/d/std_map.i | 6 ++++++ Lib/go/std_map.i | 6 ++++++ Lib/guile/std_map.i | 36 ++++++++++++++++++++++++++++++++++++ Lib/java/std_map.i | 1 - Lib/javascript/jsc/std_map.i | 7 +++++++ Lib/javascript/v8/std_map.i | 6 ++++++ Lib/lua/std_map.i | 6 ++++++ Lib/mzscheme/std_map.i | 36 ++++++++++++++++++++++++++++++++++++ Lib/ocaml/std_map.i | 6 ++++++ Lib/perl5/std_map.i | 6 ++++++ Lib/php/std_map.i | 6 ++++++ Lib/scilab/std_map.i | 10 ++++++++++ Lib/std/std_map.i | 1 - Lib/tcl/std_map.i | 6 ++++++ 15 files changed, 142 insertions(+), 2 deletions(-) diff --git a/Lib/csharp/std_map.i b/Lib/csharp/std_map.i index 9d07bc830..9884e29a5 100644 --- a/Lib/csharp/std_map.i +++ b/Lib/csharp/std_map.i @@ -214,6 +214,11 @@ typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; map(); map(const map< K, T, C > &other); diff --git a/Lib/d/std_map.i b/Lib/d/std_map.i index b7da364cc..b869ac599 100644 --- a/Lib/d/std_map.i +++ b/Lib/d/std_map.i @@ -23,6 +23,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/go/std_map.i b/Lib/go/std_map.i index 3077d157f..5e21591e9 100644 --- a/Lib/go/std_map.i +++ b/Lib/go/std_map.i @@ -27,6 +27,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/guile/std_map.i b/Lib/guile/std_map.i index 4b8dd67c2..4ac22c23d 100644 --- a/Lib/guile/std_map.i +++ b/Lib/guile/std_map.i @@ -218,6 +218,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); @@ -434,6 +440,16 @@ namespace std { %rename("delete!") __delitem__; %rename("has-key?") has_key; public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); @@ -640,6 +656,16 @@ namespace std { %rename("delete!") __delitem__; %rename("has-key?") has_key; public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); @@ -848,6 +874,16 @@ namespace std { %rename("delete!") __delitem__; %rename("has-key?") has_key; public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index 0b0041fb8..7ba0b2fe5 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -147,7 +147,6 @@ template typedef KeyType key_type; typedef MappedType mapped_type; typedef std::pair< const KeyType, MappedType > value_type; - typedef Compare key_compare; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; diff --git a/Lib/javascript/jsc/std_map.i b/Lib/javascript/jsc/std_map.i index cc9474abc..17b56bd48 100644 --- a/Lib/javascript/jsc/std_map.i +++ b/Lib/javascript/jsc/std_map.i @@ -27,6 +27,13 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + + map(); map(const map< K, T, C >& other); diff --git a/Lib/javascript/v8/std_map.i b/Lib/javascript/v8/std_map.i index cc9474abc..41ee1760e 100644 --- a/Lib/javascript/v8/std_map.i +++ b/Lib/javascript/v8/std_map.i @@ -27,6 +27,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/lua/std_map.i b/Lib/lua/std_map.i index 3077d157f..5e21591e9 100644 --- a/Lib/lua/std_map.i +++ b/Lib/lua/std_map.i @@ -27,6 +27,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/mzscheme/std_map.i b/Lib/mzscheme/std_map.i index 68c7f7fb1..80a16ced0 100644 --- a/Lib/mzscheme/std_map.i +++ b/Lib/mzscheme/std_map.i @@ -221,6 +221,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); @@ -441,6 +447,16 @@ namespace std { %rename("delete!") __delitem__; %rename("has-key?") has_key; public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); @@ -653,6 +669,16 @@ namespace std { %rename("delete!") __delitem__; %rename("has-key?") has_key; public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); @@ -865,6 +891,16 @@ namespace std { %rename("delete!") __delitem__; %rename("has-key?") has_key; public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/ocaml/std_map.i b/Lib/ocaml/std_map.i index b50bc7fc0..9ce881699 100644 --- a/Lib/ocaml/std_map.i +++ b/Lib/ocaml/std_map.i @@ -26,6 +26,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/perl5/std_map.i b/Lib/perl5/std_map.i index fe9b6f3f1..91a2acd06 100644 --- a/Lib/perl5/std_map.i +++ b/Lib/perl5/std_map.i @@ -27,6 +27,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/php/std_map.i b/Lib/php/std_map.i index 4d93fa144..64c4ff18d 100644 --- a/Lib/php/std_map.i +++ b/Lib/php/std_map.i @@ -27,6 +27,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/scilab/std_map.i b/Lib/scilab/std_map.i index aea1c7141..de00534b0 100644 --- a/Lib/scilab/std_map.i +++ b/Lib/scilab/std_map.i @@ -22,6 +22,16 @@ namespace std { template > class map { // add typemaps here public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); diff --git a/Lib/std/std_map.i b/Lib/std/std_map.i index 36c037860..62f5cb37c 100644 --- a/Lib/std/std_map.i +++ b/Lib/std/std_map.i @@ -74,7 +74,6 @@ namespace std { typedef _Key key_type; typedef _Tp mapped_type; typedef std::pair< const _Key, _Tp > value_type; - typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; diff --git a/Lib/tcl/std_map.i b/Lib/tcl/std_map.i index d59537922..ce1381f03 100644 --- a/Lib/tcl/std_map.i +++ b/Lib/tcl/std_map.i @@ -26,6 +26,12 @@ namespace std { typedef ptrdiff_t difference_type; typedef K key_type; typedef T mapped_type; + typedef std::pair< const K, T > value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + map(); map(const map< K, T, C >& other); From a47c2553f512f8ad1e1c076a81e0baa84fc5f2a1 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Tue, 12 Feb 2019 23:02:38 +0000 Subject: [PATCH 18/26] Add missing typedefs to std::pair --- Lib/csharp/std_pair.i | 2 ++ Lib/d/std_pair.i | 2 ++ Lib/go/std_pair.i | 2 ++ Lib/guile/std_pair.i | 4 ++++ Lib/java/std_pair.i | 3 +++ Lib/javascript/jsc/std_pair.i | 2 ++ Lib/javascript/v8/std_pair.i | 2 ++ Lib/lua/std_pair.i | 16 ---------------- Lib/mzscheme/std_pair.i | 4 ++++ Lib/ocaml/std_pair.i | 2 ++ Lib/perl5/std_pair.i | 2 ++ Lib/php/std_pair.i | 2 ++ Lib/scilab/std_pair.i | 2 ++ Lib/tcl/std_pair.i | 2 ++ 14 files changed, 31 insertions(+), 16 deletions(-) diff --git a/Lib/csharp/std_pair.i b/Lib/csharp/std_pair.i index 0712ad762..932849017 100644 --- a/Lib/csharp/std_pair.i +++ b/Lib/csharp/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T t, U u); diff --git a/Lib/d/std_pair.i b/Lib/d/std_pair.i index 0712ad762..932849017 100644 --- a/Lib/d/std_pair.i +++ b/Lib/d/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T t, U u); diff --git a/Lib/go/std_pair.i b/Lib/go/std_pair.i index fe45ee676..867bb2cd5 100644 --- a/Lib/go/std_pair.i +++ b/Lib/go/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T first, U second); diff --git a/Lib/guile/std_pair.i b/Lib/guile/std_pair.i index 92dec5fae..e738ecec9 100644 --- a/Lib/guile/std_pair.i +++ b/Lib/guile/std_pair.i @@ -113,6 +113,10 @@ namespace std { $1 = 0; } } + + typedef T first_type; + typedef U second_type; + pair(); pair(T first, U second); pair(const pair& p); diff --git a/Lib/java/std_pair.i b/Lib/java/std_pair.i index fe45ee676..1454eaa9c 100644 --- a/Lib/java/std_pair.i +++ b/Lib/java/std_pair.i @@ -18,6 +18,9 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; + pair(); pair(T first, U second); diff --git a/Lib/javascript/jsc/std_pair.i b/Lib/javascript/jsc/std_pair.i index fe45ee676..867bb2cd5 100644 --- a/Lib/javascript/jsc/std_pair.i +++ b/Lib/javascript/jsc/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T first, U second); diff --git a/Lib/javascript/v8/std_pair.i b/Lib/javascript/v8/std_pair.i index 8d6057223..7530e374e 100644 --- a/Lib/javascript/v8/std_pair.i +++ b/Lib/javascript/v8/std_pair.i @@ -17,6 +17,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T first, U second); diff --git a/Lib/lua/std_pair.i b/Lib/lua/std_pair.i index eee365c82..558887789 100644 --- a/Lib/lua/std_pair.i +++ b/Lib/lua/std_pair.i @@ -7,21 +7,6 @@ %{ #include %} -/* -A really cut down version of the pair class. - -this is not useful on its own - it needs a %template definition with it - -eg. -namespace std { - %template(IntPair) pair; - %template(make_IntPair) make_pair; -} - - -*/ - - namespace std { template struct pair { @@ -38,5 +23,4 @@ namespace std { template pair make_pair(const T& t,const U& u); - } diff --git a/Lib/mzscheme/std_pair.i b/Lib/mzscheme/std_pair.i index d5a65470d..52d2bdf87 100644 --- a/Lib/mzscheme/std_pair.i +++ b/Lib/mzscheme/std_pair.i @@ -115,6 +115,10 @@ namespace std { $1 = 0; } } + + typedef T first_type; + typedef U second_type; + pair(); pair(T first, U second); pair(const pair& p); diff --git a/Lib/ocaml/std_pair.i b/Lib/ocaml/std_pair.i index fe45ee676..867bb2cd5 100644 --- a/Lib/ocaml/std_pair.i +++ b/Lib/ocaml/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T first, U second); diff --git a/Lib/perl5/std_pair.i b/Lib/perl5/std_pair.i index 0712ad762..932849017 100644 --- a/Lib/perl5/std_pair.i +++ b/Lib/perl5/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T t, U u); diff --git a/Lib/php/std_pair.i b/Lib/php/std_pair.i index fe45ee676..867bb2cd5 100644 --- a/Lib/php/std_pair.i +++ b/Lib/php/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T first, U second); diff --git a/Lib/scilab/std_pair.i b/Lib/scilab/std_pair.i index 1448d6524..bd0eb53fe 100644 --- a/Lib/scilab/std_pair.i +++ b/Lib/scilab/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T first, U second); diff --git a/Lib/tcl/std_pair.i b/Lib/tcl/std_pair.i index 1448d6524..bd0eb53fe 100644 --- a/Lib/tcl/std_pair.i +++ b/Lib/tcl/std_pair.i @@ -18,6 +18,8 @@ namespace std { template struct pair { + typedef T first_type; + typedef U second_type; pair(); pair(T first, U second); From e26f6bb4e21b7adc90fcd916ec3cbd39e583637e Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Wed, 13 Feb 2019 00:04:26 +0000 Subject: [PATCH 19/26] Add missing typedefs to std::vector + typedef corrections Tests for std::vector of pointers added which check std::vector::const_reference and std::vector::reference usage which gave compilation errors in Python and Perl which had specialized these vectors incorrectly. --- Examples/test-suite/li_std_vector_extra.i | 1 + Examples/test-suite/li_std_vector_ptr.i | 13 +++++++++++ .../python/li_std_vector_extra_runme.py | 8 +++++++ .../python/li_std_vector_ptr_runme.py | 10 ++++++++- Lib/csharp/std_vector.i | 5 +++++ Lib/d/std_vector.i | 10 +++++++++ Lib/go/std_vector.i | 10 +++++++++ Lib/guile/std_vector.i | 16 ++++++++++++++ Lib/java/std_vector.i | 8 +++---- Lib/javascript/jsc/std_vector.i | 11 ++++++++++ Lib/javascript/v8/std_vector.i | 10 +++++++++ Lib/lua/std_vector.i | 8 +++++++ Lib/mzscheme/std_vector.i | 16 ++++++++++++++ Lib/ocaml/std_vector.i | 8 +++++++ Lib/perl5/std_vector.i | 17 +++++++++++++- Lib/php/std_vector.i | 10 +++++++++ Lib/std/std_vector.i | 22 +++++++++---------- Lib/tcl/std_vector.i | 16 ++++++++++++++ 18 files changed, 182 insertions(+), 17 deletions(-) diff --git a/Examples/test-suite/li_std_vector_extra.i b/Examples/test-suite/li_std_vector_extra.i index 114de3f11..103242b24 100644 --- a/Examples/test-suite/li_std_vector_extra.i +++ b/Examples/test-suite/li_std_vector_extra.i @@ -129,6 +129,7 @@ std::vector vecStr(std::vector v) { double *makeDoublePtr(double v) { return new double(v); } int extractInt(int *p) { return *p; } short extractConstShort(const short *p) { return *p; } + short extractConstShort2(std::vector::value_type p) { return *p; } %} %template(pyvector) std::vector; diff --git a/Examples/test-suite/li_std_vector_ptr.i b/Examples/test-suite/li_std_vector_ptr.i index 8c3b71e65..dcf1128e0 100644 --- a/Examples/test-suite/li_std_vector_ptr.i +++ b/Examples/test-suite/li_std_vector_ptr.i @@ -15,6 +15,19 @@ using namespace std; int* makeIntPtr(int v) { return new int(v); } +std::vector::value_type makeIntPtr2(int v) { + return new int(v); +} +int getIntValue(int *p) { + return *p; +} +int getIntValue2(std::vector::const_reference p) { + return *p; +} +int getIntValue3(std::vector::reference p) { + return *p; +} + double* makeDoublePtr(double v) { return new double(v); } diff --git a/Examples/test-suite/python/li_std_vector_extra_runme.py b/Examples/test-suite/python/li_std_vector_extra_runme.py index d541de6db..88105ea85 100644 --- a/Examples/test-suite/python/li_std_vector_extra_runme.py +++ b/Examples/test-suite/python/li_std_vector_extra_runme.py @@ -173,3 +173,11 @@ if extractConstShort(vcs[0]) != 111: if extractConstShort(vcs[1]) != 222: raise RuntimeError + +for p in vcs[0:1]: + if extractConstShort2(p) != 111: + raise RuntimeError + +for p in vcs[1:2]: + if extractConstShort2(p) != 222: + raise RuntimeError diff --git a/Examples/test-suite/python/li_std_vector_ptr_runme.py b/Examples/test-suite/python/li_std_vector_ptr_runme.py index baa92cfee..875d1c9c9 100644 --- a/Examples/test-suite/python/li_std_vector_ptr_runme.py +++ b/Examples/test-suite/python/li_std_vector_ptr_runme.py @@ -4,12 +4,20 @@ def check(val1, val2): if val1 != val2: raise RuntimeError("Values are not the same %s %s" % (val1, val2)) ip1 = makeIntPtr(11) -ip2 = makeIntPtr(22) +ip2 = makeIntPtr2(22) vi = IntPtrVector((ip1, ip2)) check(getValueFromVector(vi, 0), 11) check(getValueFromVector(vi, 1), 22) +check(getIntValue(vi[0]), 11) +check(getIntValue(vi[1]), 22) +check(getIntValue2(vi[0]), 11) +check(getIntValue2(vi[1]), 22) + +ipp = makeIntPtrPtr(vi[0]) +check(getIntValue3(ipp), 11) # Note: getIntValue3 takes int** + vA = APtrVector([makeA(33), makeA(34)]) check(getVectorValueA(vA, 0), 33) diff --git a/Lib/csharp/std_vector.i b/Lib/csharp/std_vector.i index a69cb63ed..fa60a061d 100644 --- a/Lib/csharp/std_vector.i +++ b/Lib/csharp/std_vector.i @@ -201,8 +201,13 @@ public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef CTYPE value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef CONST_REFERENCE const_reference; + %rename(Clear) clear; void clear(); %rename(Add) push_back; diff --git a/Lib/d/std_vector.i b/Lib/d/std_vector.i index c67057180..cba3cd4a6 100644 --- a/Lib/d/std_vector.i +++ b/Lib/d/std_vector.i @@ -104,8 +104,13 @@ public void capacity(size_t value) { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef CTYPE value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef CONST_REFERENCE const_reference; + void clear(); void push_back(CTYPE const& x); size_type size() const; @@ -442,8 +447,13 @@ int opApply(int delegate(ref size_t index, ref $typemap(dtype, CTYPE) value) dg) public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef CTYPE value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef CONST_REFERENCE const_reference; + bool empty() const; void clear(); void push_back(CTYPE const& x); diff --git a/Lib/go/std_vector.i b/Lib/go/std_vector.i index 29bcd1391..708e5ee38 100644 --- a/Lib/go/std_vector.i +++ b/Lib/go/std_vector.i @@ -12,8 +12,13 @@ namespace std { template class vector { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef const value_type& const_reference; + vector(); vector(size_type n); size_type size() const; @@ -46,8 +51,13 @@ namespace std { template<> class vector { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef bool value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef bool const_reference; + vector(); vector(size_type n); size_type size() const; diff --git a/Lib/guile/std_vector.i b/Lib/guile/std_vector.i index c144f879c..4f7538317 100644 --- a/Lib/guile/std_vector.i +++ b/Lib/guile/std_vector.i @@ -187,6 +187,14 @@ namespace std { } } public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, const T& value); vector(const vector& other); @@ -351,6 +359,14 @@ namespace std { } } public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, const T& value); vector(const vector& other); diff --git a/Lib/java/std_vector.i b/Lib/java/std_vector.i index cb1752c69..6a66ec10a 100644 --- a/Lib/java/std_vector.i +++ b/Lib/java/std_vector.i @@ -23,7 +23,7 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) { } } -%define SWIG_STD_VECTOR_MINIMUM_INTERNAL(CTYPE, CREF_TYPE) +%define SWIG_STD_VECTOR_MINIMUM_INTERNAL(CTYPE, CONST_REFERENCE) %typemap(javabase) std::vector< CTYPE > "java.util.AbstractList<$typemap(jboxtype, CTYPE)>" %typemap(javainterfaces) std::vector< CTYPE > "java.util.RandomAccess" %proxycode %{ @@ -79,10 +79,10 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) { typedef size_t size_type; typedef ptrdiff_t difference_type; typedef CTYPE value_type; - typedef CTYPE &reference; - typedef CREF_TYPE const_reference; typedef CTYPE *pointer; typedef CTYPE const *const_pointer; + typedef CTYPE &reference; + typedef CONST_REFERENCE const_reference; vector(); vector(const vector &other); @@ -133,7 +133,7 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) { } } - CREF_TYPE doGet(jint index) throw (std::out_of_range) { + CONST_REFERENCE doGet(jint index) throw (std::out_of_range) { jint size = static_cast(self->size()); if (index >= 0 && index < size) return (*self)[index]; diff --git a/Lib/javascript/jsc/std_vector.i b/Lib/javascript/jsc/std_vector.i index 971b426a1..34e21a821 100644 --- a/Lib/javascript/jsc/std_vector.i +++ b/Lib/javascript/jsc/std_vector.i @@ -14,8 +14,13 @@ namespace std { template class vector { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef const value_type& const_reference; + vector(); vector(size_type n); size_type size() const; @@ -48,8 +53,14 @@ namespace std { template<> class vector { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef bool value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef bool const_reference; + + vector(); vector(size_type n); size_type size() const; diff --git a/Lib/javascript/v8/std_vector.i b/Lib/javascript/v8/std_vector.i index 971b426a1..eef0f65ee 100644 --- a/Lib/javascript/v8/std_vector.i +++ b/Lib/javascript/v8/std_vector.i @@ -14,8 +14,13 @@ namespace std { template class vector { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef const value_type& const_reference; + vector(); vector(size_type n); size_type size() const; @@ -48,8 +53,13 @@ namespace std { template<> class vector { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef bool value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef bool const_reference; + vector(); vector(size_type n); size_type size() const; diff --git a/Lib/lua/std_vector.i b/Lib/lua/std_vector.i index 3199a9dab..695862d66 100644 --- a/Lib/lua/std_vector.i +++ b/Lib/lua/std_vector.i @@ -25,6 +25,14 @@ namespace std { template class vector { public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + vector(); vector(unsigned int); vector(const vector& other); diff --git a/Lib/mzscheme/std_vector.i b/Lib/mzscheme/std_vector.i index 9fa2d5497..012c32d32 100644 --- a/Lib/mzscheme/std_vector.i +++ b/Lib/mzscheme/std_vector.i @@ -189,6 +189,14 @@ namespace std { } } public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, const T& value); vector(const vector& other); @@ -365,6 +373,14 @@ namespace std { } } public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, const T& value); vector(const vector& other); diff --git a/Lib/ocaml/std_vector.i b/Lib/ocaml/std_vector.i index 053b645f0..f15b26c66 100644 --- a/Lib/ocaml/std_vector.i +++ b/Lib/ocaml/std_vector.i @@ -41,6 +41,14 @@ namespace std { template class vector { public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, const T& value); vector(const vector& other); diff --git a/Lib/perl5/std_vector.i b/Lib/perl5/std_vector.i index adfe95df6..a0c26192e 100644 --- a/Lib/perl5/std_vector.i +++ b/Lib/perl5/std_vector.i @@ -181,8 +181,13 @@ namespace std { } public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, const T& value); vector(const vector& other); @@ -353,8 +358,13 @@ namespace std { } public: typedef size_t size_type; - typedef T value_type; + typedef ptrdiff_t difference_type; + typedef T* value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, T *value); vector(const vector& other); @@ -524,8 +534,13 @@ namespace std { } public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, T value); vector(const vector& other); diff --git a/Lib/php/std_vector.i b/Lib/php/std_vector.i index 9cc1486ef..fe2b8d07d 100644 --- a/Lib/php/std_vector.i +++ b/Lib/php/std_vector.i @@ -14,8 +14,13 @@ namespace std { template class vector { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef const value_type& const_reference; + vector(); vector(size_type n); size_type size() const; @@ -56,8 +61,13 @@ namespace std { template<> class vector { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef bool value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef bool const_reference; + vector(); vector(size_type n); size_type size() const; diff --git a/Lib/std/std_vector.i b/Lib/std/std_vector.i index fae759a36..b35f03bea 100644 --- a/Lib/std/std_vector.i +++ b/Lib/std/std_vector.i @@ -64,8 +64,8 @@ namespace std { typedef _Tp value_type; typedef value_type* pointer; typedef const value_type* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; + typedef value_type& reference; + typedef const value_type& const_reference; typedef _Alloc allocator_type; %traits_swigtype(_Tp); @@ -101,13 +101,13 @@ namespace std { template class vector< _Tp*, _Alloc > { public: - typedef size_t size_type; + typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Tp* value_type; typedef value_type* pointer; typedef const value_type* const_pointer; - typedef value_type reference; - typedef value_type const_reference; + typedef value_type& reference; + typedef const value_type& const_reference; typedef _Alloc allocator_type; %traits_swigtype(_Tp); @@ -141,13 +141,13 @@ namespace std { template class vector< _Tp const *, _Alloc > { public: - typedef size_t size_type; + typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Tp const * value_type; typedef value_type* pointer; typedef const value_type* const_pointer; - typedef value_type reference; - typedef value_type const_reference; + typedef value_type& reference; + typedef const value_type& const_reference; typedef _Alloc allocator_type; %traits_swigtype(_Tp); @@ -182,13 +182,13 @@ namespace std { template class vector { public: - typedef size_t size_type; + typedef size_t size_type; typedef ptrdiff_t difference_type; typedef bool value_type; typedef value_type* pointer; typedef const value_type* const_pointer; - typedef value_type reference; - typedef value_type const_reference; + typedef value_type& reference; + typedef bool const_reference; typedef _Alloc allocator_type; %traits_swigtype(bool); diff --git a/Lib/tcl/std_vector.i b/Lib/tcl/std_vector.i index 71913f389..bb227cf3d 100644 --- a/Lib/tcl/std_vector.i +++ b/Lib/tcl/std_vector.i @@ -208,6 +208,14 @@ namespace std { } public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, const T& value); vector(const vector< T >& other); @@ -359,6 +367,14 @@ namespace std { } public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + vector(unsigned int size = 0); vector(unsigned int size, const T& value); vector(const vector< T >& other); From 440264e4797b0941f410dbfe6385285dd0daa20b Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 14 Feb 2019 07:31:21 +0000 Subject: [PATCH 20/26] Add missing typedefs to std::list + typedef corrections Numerous missing typedefs added. std::list::const_reference and std::list::reference specialization typedef fixes. --- Lib/allegrocl/std_list.i | 25 +++++++++++++------------ Lib/go/std_list.i | 5 ++--- Lib/java/std_list.i | 6 +++++- Lib/ocaml/std_list.i | 27 +++++++++++++-------------- Lib/perl5/std_list.i | 4 ++++ Lib/std/std_list.i | 4 ++-- 6 files changed, 39 insertions(+), 32 deletions(-) diff --git a/Lib/allegrocl/std_list.i b/Lib/allegrocl/std_list.i index 332691de1..26472156f 100644 --- a/Lib/allegrocl/std_list.i +++ b/Lib/allegrocl/std_list.i @@ -28,12 +28,16 @@ namespace std{ template class list { public: - - typedef T &reference; - typedef const T& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; typedef T &iterator; typedef const T& const_iterator; - + list(); list(unsigned int size, const T& value = T()); list(const list &other); @@ -46,21 +50,20 @@ namespace std{ const_reference back(); const_iterator begin(); const_iterator end(); - + void resize(unsigned int n, T c = T()); bool empty() const; void push_front(const T& INPUT); void push_back(const T& INPUT); - void pop_front(); void pop_back(); void clear(); unsigned int size() const; unsigned int max_size() const; void resize(unsigned int n, const T& INPUT); - + void remove(const T& INPUT); void unique(); void reverse(); @@ -153,7 +156,7 @@ namespace std{ if (j<0) j += size; if (i<0) i = 0; if (j>size) j = size; - + for (int k=0;ksize) j = size; - + for (int k=0;kinsert(self->end(),v.begin(),v.end()); } - } unsigned int __len__() { @@ -218,8 +220,7 @@ namespace std{ { self->pop_back(); } - - }; + } }; } diff --git a/Lib/go/std_list.i b/Lib/go/std_list.i index e0262331e..b6e9b6a5a 100644 --- a/Lib/go/std_list.i +++ b/Lib/go/std_list.i @@ -1,5 +1,5 @@ /* ----------------------------------------------------------------------------- - * std_vector.i + * std_list.i * ----------------------------------------------------------------------------- */ %{ @@ -9,7 +9,7 @@ namespace std { - template > + template class list { public: typedef size_t size_type; @@ -19,7 +19,6 @@ namespace std { typedef const value_type* const_pointer; typedef value_type& reference; typedef const value_type& const_reference; - typedef Alloc allocator_type; list(); size_type size() const; diff --git a/Lib/java/std_list.i b/Lib/java/std_list.i index 595db8919..516a36ee3 100644 --- a/Lib/java/std_list.i +++ b/Lib/java/std_list.i @@ -130,8 +130,12 @@ namespace std { public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef T value_type; - typedef T &reference; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; /* * We'd actually be better off having the nested class *not* be static in the wrapper diff --git a/Lib/ocaml/std_list.i b/Lib/ocaml/std_list.i index cb648d711..e173d8b1e 100644 --- a/Lib/ocaml/std_list.i +++ b/Lib/ocaml/std_list.i @@ -13,16 +13,20 @@ %} -namespace std{ +namespace std { template class list { public: - - typedef T &reference; - typedef const T& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; typedef T &iterator; typedef const T& const_iterator; - + list(); list(unsigned int size, const T& value = T()); list(const list& other); @@ -35,28 +39,25 @@ namespace std{ const_reference back(); const_iterator begin(); const_iterator end(); - + void resize(unsigned int n, T c = T()); bool empty() const; void push_front(const T& x); void push_back(const T& x); - void pop_front(); void pop_back(); void clear(); unsigned int size() const; unsigned int max_size() const; void resize(unsigned int n, const T& value); - + void remove(const T& value); void unique(); void reverse(); void sort(); - - - + %extend { const_reference __getitem__(int i) throw (std::out_of_range) @@ -206,9 +207,7 @@ namespace std{ { self->pop_back(); } - - }; - + } }; } diff --git a/Lib/perl5/std_list.i b/Lib/perl5/std_list.i index 8e2945fba..d42e3d8ef 100644 --- a/Lib/perl5/std_list.i +++ b/Lib/perl5/std_list.i @@ -189,7 +189,11 @@ namespace std { } public: typedef size_t size_type; + typedef ptrdiff_t difference_type; typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; typedef const value_type& const_reference; list(); diff --git a/Lib/std/std_list.i b/Lib/std/std_list.i index ebbafa22b..2cc2d97cf 100644 --- a/Lib/std/std_list.i +++ b/Lib/std/std_list.i @@ -106,8 +106,8 @@ namespace std { typedef _Tp* value_type; typedef value_type* pointer; typedef const value_type* const_pointer; - typedef value_type reference; - typedef value_type const_reference; + typedef value_type& reference; + typedef const value_type& const_reference; typedef _Alloc allocator_type; %traits_swigtype(_Tp); From 40d7f4137e97b2814b2405bef6372b8edcc67454 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 14 Feb 2019 07:38:49 +0000 Subject: [PATCH 21/26] typedef declaration corrections for std::array --- Lib/java/std_array.i | 10 ++++++---- Lib/std/std_array.i | 4 ++-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/Lib/java/std_array.i b/Lib/java/std_array.i index 0944d932f..f67b18d9b 100644 --- a/Lib/java/std_array.i +++ b/Lib/java/std_array.i @@ -11,12 +11,14 @@ namespace std { typedef size_t size_type; typedef ptrdiff_t difference_type; typedef T value_type; - typedef T &reference; - typedef const T &const_reference; - typedef T *pointer; - typedef const T *const_pointer; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + array(); array(const array& other); + size_type size() const; %rename(isEmpty) empty; bool empty() const; diff --git a/Lib/std/std_array.i b/Lib/std/std_array.i index aadc3b80c..3f70ef57c 100644 --- a/Lib/std/std_array.i +++ b/Lib/std/std_array.i @@ -53,8 +53,8 @@ namespace std { typedef _Tp value_type; typedef value_type* pointer; typedef const value_type* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; + typedef value_type& reference; + typedef const value_type& const_reference; %traits_swigtype(_Tp); %traits_enum(_Tp); From dc34c39c533b76bf5d8fd13e47906f6a4de16800 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 14 Feb 2019 08:16:16 +0000 Subject: [PATCH 22/26] Cosmetic STL typedef changes --- Lib/java/std_set.i | 4 ++-- Lib/java/std_unordered_set.i | 4 ++-- Lib/std/std_multimap.i | 1 - Lib/std/std_unordered_map.i | 1 - Lib/std/std_unordered_multimap.i | 1 - 5 files changed, 4 insertions(+), 7 deletions(-) diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i index 4453d90bd..ddc0379cd 100644 --- a/Lib/java/std_set.i +++ b/Lib/java/std_set.i @@ -150,10 +150,10 @@ class set { } }; - typedef T key_type; - typedef T value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; + typedef T value_type; + typedef T key_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i index 06c7a1123..98bf3ebf1 100644 --- a/Lib/java/std_unordered_set.i +++ b/Lib/java/std_unordered_set.i @@ -150,10 +150,10 @@ class unordered_set { } }; - typedef T key_type; - typedef T value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; + typedef T value_type; + typedef T key_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; diff --git a/Lib/std/std_multimap.i b/Lib/std/std_multimap.i index 983a5d8fd..03e765341 100644 --- a/Lib/std/std_multimap.i +++ b/Lib/std/std_multimap.i @@ -50,7 +50,6 @@ namespace std { typedef _Key key_type; typedef _Tp mapped_type; typedef std::pair< const _Key, _Tp > value_type; - typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; diff --git a/Lib/std/std_unordered_map.i b/Lib/std/std_unordered_map.i index 0d6986497..723c0232d 100644 --- a/Lib/std/std_unordered_map.i +++ b/Lib/std/std_unordered_map.i @@ -71,7 +71,6 @@ namespace std { typedef _Key key_type; typedef _Tp mapped_type; typedef std::pair< const _Key, _Tp > value_type; - typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; diff --git a/Lib/std/std_unordered_multimap.i b/Lib/std/std_unordered_multimap.i index 6f1be9cfa..f2855343d 100644 --- a/Lib/std/std_unordered_multimap.i +++ b/Lib/std/std_unordered_multimap.i @@ -49,7 +49,6 @@ namespace std { typedef _Key key_type; typedef _Tp mapped_type; typedef std::pair< const _Key, _Tp > value_type; - typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; From 6d27ead9c0d42588794ff582ecfe9af904d823b4 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 14 Feb 2019 18:53:05 +0000 Subject: [PATCH 23/26] Add STL container copy constructors where missing Also provide consistent copy constructor declarations. --- Lib/allegrocl/std_list.i | 3 +-- Lib/csharp/std_map.i | 2 +- Lib/csharp/std_vector.i | 2 ++ Lib/d/std_map.i | 2 +- Lib/d/std_vector.i | 4 ++++ Lib/go/std_list.i | 2 ++ Lib/go/std_map.i | 2 +- Lib/go/std_vector.i | 4 ++++ Lib/guile/std_map.i | 8 ++++---- Lib/guile/std_vector.i | 6 ++++-- Lib/java/std_list.i | 3 ++- Lib/java/std_map.i | 2 +- Lib/java/std_set.i | 2 +- Lib/java/std_unordered_map.i | 2 +- Lib/java/std_unordered_set.i | 2 +- Lib/java/std_vector.i | 1 + Lib/javascript/jsc/std_map.i | 2 +- Lib/javascript/jsc/std_vector.i | 5 ++++- Lib/javascript/v8/std_map.i | 2 +- Lib/javascript/v8/std_vector.i | 4 ++++ Lib/lua/std_map.i | 2 +- Lib/lua/std_vector.i | 1 + Lib/mzscheme/std_map.i | 8 ++++---- Lib/mzscheme/std_vector.i | 6 ++++-- Lib/ocaml/std_list.i | 3 +-- Lib/ocaml/std_map.i | 2 +- Lib/ocaml/std_vector.i | 3 ++- Lib/perl5/std_list.i | 4 ++-- Lib/perl5/std_map.i | 2 +- Lib/perl5/std_vector.i | 6 +++--- Lib/php/std_map.i | 2 +- Lib/php/std_vector.i | 4 ++++ Lib/scilab/std_map.i | 2 +- Lib/std/std_carray.swg | 4 ++-- Lib/tcl/std_map.i | 2 +- Lib/tcl/std_vector.i | 4 ++-- 36 files changed, 72 insertions(+), 43 deletions(-) diff --git a/Lib/allegrocl/std_list.i b/Lib/allegrocl/std_list.i index 26472156f..a3660c9f7 100644 --- a/Lib/allegrocl/std_list.i +++ b/Lib/allegrocl/std_list.i @@ -40,9 +40,8 @@ namespace std{ list(); list(unsigned int size, const T& value = T()); - list(const list &other); + list(const list& other); - ~list(); void assign(unsigned int n, const T& value); void swap(list &x); diff --git a/Lib/csharp/std_map.i b/Lib/csharp/std_map.i index 9884e29a5..e538a03a1 100644 --- a/Lib/csharp/std_map.i +++ b/Lib/csharp/std_map.i @@ -221,7 +221,7 @@ typedef const value_type& const_reference; map(); - map(const map< K, T, C > &other); + map(const map& other); size_type size() const; bool empty() const; %rename(Clear) clear; diff --git a/Lib/csharp/std_vector.i b/Lib/csharp/std_vector.i index fa60a061d..b1e8da963 100644 --- a/Lib/csharp/std_vector.i +++ b/Lib/csharp/std_vector.i @@ -217,8 +217,10 @@ void reserve(size_type n); %newobject GetRange(int index, int count); %newobject Repeat(CTYPE const& value, int count); + vector(); vector(const vector &other); + %extend { vector(int capacity) throw (std::out_of_range) { std::vector< CTYPE >* pv = 0; diff --git a/Lib/d/std_map.i b/Lib/d/std_map.i index b869ac599..c5e03d06d 100644 --- a/Lib/d/std_map.i +++ b/Lib/d/std_map.i @@ -30,7 +30,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/d/std_vector.i b/Lib/d/std_vector.i index cba3cd4a6..9dcb184c6 100644 --- a/Lib/d/std_vector.i +++ b/Lib/d/std_vector.i @@ -116,8 +116,10 @@ public void capacity(size_t value) { size_type size() const; size_type capacity() const; void reserve(size_type n) throw (std::length_error); + vector(); vector(const vector &other); + %extend { vector(size_type capacity) throw (std::length_error) { std::vector< CTYPE >* pv = 0; @@ -461,8 +463,10 @@ int opApply(int delegate(ref size_t index, ref $typemap(dtype, CTYPE) value) dg) size_type size() const; size_type capacity() const; void reserve(size_type n) throw (std::length_error); + vector(); vector(const vector &other); + %extend { vector(size_type capacity) throw (std::length_error) { std::vector< CTYPE >* pv = 0; diff --git a/Lib/go/std_list.i b/Lib/go/std_list.i index b6e9b6a5a..ff6f70013 100644 --- a/Lib/go/std_list.i +++ b/Lib/go/std_list.i @@ -21,6 +21,8 @@ namespace std { typedef const value_type& const_reference; list(); + list(const list& other); + size_type size() const; bool empty() const; %rename(isEmpty) empty; diff --git a/Lib/go/std_map.i b/Lib/go/std_map.i index 5e21591e9..773b6d0c3 100644 --- a/Lib/go/std_map.i +++ b/Lib/go/std_map.i @@ -34,7 +34,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/go/std_vector.i b/Lib/go/std_vector.i index 708e5ee38..679c70759 100644 --- a/Lib/go/std_vector.i +++ b/Lib/go/std_vector.i @@ -21,6 +21,8 @@ namespace std { vector(); vector(size_type n); + vector(const vector& other); + size_type size() const; size_type capacity() const; void reserve(size_type n); @@ -60,6 +62,8 @@ namespace std { vector(); vector(size_type n); + vector(const vector& other); + size_type size() const; size_type capacity() const; void reserve(size_type n); diff --git a/Lib/guile/std_map.i b/Lib/guile/std_map.i index 4ac22c23d..f84e78bc3 100644 --- a/Lib/guile/std_map.i +++ b/Lib/guile/std_map.i @@ -225,7 +225,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; @@ -451,7 +451,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; @@ -667,7 +667,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; @@ -885,7 +885,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/guile/std_vector.i b/Lib/guile/std_vector.i index 4f7538317..42bad849d 100644 --- a/Lib/guile/std_vector.i +++ b/Lib/guile/std_vector.i @@ -197,7 +197,8 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector& other); + vector(const vector& other); + %rename(length) size; unsigned int size() const; %rename("empty?") empty; @@ -369,7 +370,8 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector& other); + vector(const vector& other); + %rename(length) size; unsigned int size() const; %rename("empty?") empty; diff --git a/Lib/java/std_list.i b/Lib/java/std_list.i index 516a36ee3..3ad6511ce 100644 --- a/Lib/java/std_list.i +++ b/Lib/java/std_list.i @@ -177,7 +177,8 @@ namespace std { }; list(); - list(const list &other); + list(const list& other); + %rename(isEmpty) empty; bool empty() const; void clear(); diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index 7ba0b2fe5..357401a4d 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -153,7 +153,7 @@ template typedef const value_type& const_reference; map(); - map(const map& other); + map(const map& other); struct iterator { %typemap(javaclassmodifiers) iterator "protected class" diff --git a/Lib/java/std_set.i b/Lib/java/std_set.i index ddc0379cd..06c5a63e7 100644 --- a/Lib/java/std_set.i +++ b/Lib/java/std_set.i @@ -160,7 +160,7 @@ class set { typedef const value_type& const_reference; set(); - set(const set& other); + set(const set& other); %rename(isEmpty) empty; bool empty() const; diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i index eecdf0bc4..57ebe4e39 100644 --- a/Lib/java/std_unordered_map.i +++ b/Lib/java/std_unordered_map.i @@ -153,7 +153,7 @@ template class unordered_map { typedef const value_type& const_reference; unordered_map(); - unordered_map(const unordered_map& other); + unordered_map(const unordered_map& other); struct iterator { %typemap(javaclassmodifiers) iterator "protected class" diff --git a/Lib/java/std_unordered_set.i b/Lib/java/std_unordered_set.i index 98bf3ebf1..cdc116e49 100644 --- a/Lib/java/std_unordered_set.i +++ b/Lib/java/std_unordered_set.i @@ -160,7 +160,7 @@ class unordered_set { typedef const value_type& const_reference; unordered_set(); - unordered_set(const unordered_set& other); + unordered_set(const unordered_set& other); %rename(isEmpty) empty; bool empty() const; diff --git a/Lib/java/std_vector.i b/Lib/java/std_vector.i index 6a66ec10a..f621e8992 100644 --- a/Lib/java/std_vector.i +++ b/Lib/java/std_vector.i @@ -86,6 +86,7 @@ SWIGINTERN jint SWIG_VectorSize(size_t size) { vector(); vector(const vector &other); + size_type capacity() const; void reserve(size_type n) throw (std::length_error); %rename(isEmpty) empty; diff --git a/Lib/javascript/jsc/std_map.i b/Lib/javascript/jsc/std_map.i index 17b56bd48..9fa10880f 100644 --- a/Lib/javascript/jsc/std_map.i +++ b/Lib/javascript/jsc/std_map.i @@ -35,7 +35,7 @@ namespace std { map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/javascript/jsc/std_vector.i b/Lib/javascript/jsc/std_vector.i index 34e21a821..586ac5c60 100644 --- a/Lib/javascript/jsc/std_vector.i +++ b/Lib/javascript/jsc/std_vector.i @@ -23,6 +23,8 @@ namespace std { vector(); vector(size_type n); + vector(const vector& other); + size_type size() const; size_type capacity() const; void reserve(size_type n); @@ -60,9 +62,10 @@ namespace std { typedef value_type& reference; typedef bool const_reference; - vector(); vector(size_type n); + vector(const vector& other); + size_type size() const; size_type capacity() const; void reserve(size_type n); diff --git a/Lib/javascript/v8/std_map.i b/Lib/javascript/v8/std_map.i index 41ee1760e..3b8b09369 100644 --- a/Lib/javascript/v8/std_map.i +++ b/Lib/javascript/v8/std_map.i @@ -34,7 +34,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/javascript/v8/std_vector.i b/Lib/javascript/v8/std_vector.i index eef0f65ee..586ac5c60 100644 --- a/Lib/javascript/v8/std_vector.i +++ b/Lib/javascript/v8/std_vector.i @@ -23,6 +23,8 @@ namespace std { vector(); vector(size_type n); + vector(const vector& other); + size_type size() const; size_type capacity() const; void reserve(size_type n); @@ -62,6 +64,8 @@ namespace std { vector(); vector(size_type n); + vector(const vector& other); + size_type size() const; size_type capacity() const; void reserve(size_type n); diff --git a/Lib/lua/std_map.i b/Lib/lua/std_map.i index 5e21591e9..773b6d0c3 100644 --- a/Lib/lua/std_map.i +++ b/Lib/lua/std_map.i @@ -34,7 +34,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/lua/std_vector.i b/Lib/lua/std_vector.i index 695862d66..9eb85e9e6 100644 --- a/Lib/lua/std_vector.i +++ b/Lib/lua/std_vector.i @@ -37,6 +37,7 @@ namespace std { vector(unsigned int); vector(const vector& other); vector(unsigned int,T); + unsigned int size() const; unsigned int max_size() const; bool empty() const; diff --git a/Lib/mzscheme/std_map.i b/Lib/mzscheme/std_map.i index 80a16ced0..1d3eec241 100644 --- a/Lib/mzscheme/std_map.i +++ b/Lib/mzscheme/std_map.i @@ -228,7 +228,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; @@ -458,7 +458,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; @@ -680,7 +680,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; @@ -902,7 +902,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/mzscheme/std_vector.i b/Lib/mzscheme/std_vector.i index 012c32d32..0ef5edb15 100644 --- a/Lib/mzscheme/std_vector.i +++ b/Lib/mzscheme/std_vector.i @@ -199,7 +199,8 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector& other); + vector(const vector& other); + %rename(length) size; unsigned int size() const; %rename("empty?") empty; @@ -383,7 +384,8 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector& other); + vector(const vector& other); + %rename(length) size; unsigned int size() const; %rename("empty?") empty; diff --git a/Lib/ocaml/std_list.i b/Lib/ocaml/std_list.i index e173d8b1e..e0524aa40 100644 --- a/Lib/ocaml/std_list.i +++ b/Lib/ocaml/std_list.i @@ -29,9 +29,8 @@ namespace std { list(); list(unsigned int size, const T& value = T()); - list(const list& other); + list(const list& other); - ~list(); void assign(unsigned int n, const T& value); void swap(list &x); diff --git a/Lib/ocaml/std_map.i b/Lib/ocaml/std_map.i index 9ce881699..3f197baa6 100644 --- a/Lib/ocaml/std_map.i +++ b/Lib/ocaml/std_map.i @@ -33,7 +33,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/ocaml/std_vector.i b/Lib/ocaml/std_vector.i index f15b26c66..891d038c9 100644 --- a/Lib/ocaml/std_vector.i +++ b/Lib/ocaml/std_vector.i @@ -51,7 +51,8 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector& other); + vector(const vector& other); + unsigned int size() const; bool empty() const; void clear(); diff --git a/Lib/perl5/std_list.i b/Lib/perl5/std_list.i index d42e3d8ef..36678add2 100644 --- a/Lib/perl5/std_list.i +++ b/Lib/perl5/std_list.i @@ -197,7 +197,7 @@ namespace std { typedef const value_type& const_reference; list(); - list(const list& other); + list(const list& other); unsigned int size() const; bool empty() const; @@ -350,7 +350,7 @@ namespace std { typedef const value_type& const_reference; list(); - list(const list& other); + list(const list& other); unsigned int size() const; bool empty() const; diff --git a/Lib/perl5/std_map.i b/Lib/perl5/std_map.i index 91a2acd06..1b3731832 100644 --- a/Lib/perl5/std_map.i +++ b/Lib/perl5/std_map.i @@ -34,7 +34,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/perl5/std_vector.i b/Lib/perl5/std_vector.i index a0c26192e..5bfd2c5ac 100644 --- a/Lib/perl5/std_vector.i +++ b/Lib/perl5/std_vector.i @@ -190,7 +190,7 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector& other); + vector(const vector& other); unsigned int size() const; bool empty() const; @@ -367,7 +367,7 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, T *value); - vector(const vector& other); + vector(const vector& other); unsigned int size() const; bool empty() const; @@ -543,7 +543,7 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, T value); - vector(const vector& other); + vector(const vector& other); unsigned int size() const; bool empty() const; diff --git a/Lib/php/std_map.i b/Lib/php/std_map.i index 64c4ff18d..7c0157353 100644 --- a/Lib/php/std_map.i +++ b/Lib/php/std_map.i @@ -34,7 +34,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; void clear(); diff --git a/Lib/php/std_vector.i b/Lib/php/std_vector.i index fe2b8d07d..e633bc3ad 100644 --- a/Lib/php/std_vector.i +++ b/Lib/php/std_vector.i @@ -23,6 +23,8 @@ namespace std { vector(); vector(size_type n); + vector(const vector& other); + size_type size() const; size_type capacity() const; void reserve(size_type n); @@ -70,6 +72,8 @@ namespace std { vector(); vector(size_type n); + vector(const vector& other); + size_type size() const; size_type capacity() const; void reserve(size_type n); diff --git a/Lib/scilab/std_map.i b/Lib/scilab/std_map.i index de00534b0..07eb63fda 100644 --- a/Lib/scilab/std_map.i +++ b/Lib/scilab/std_map.i @@ -33,7 +33,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/std/std_carray.swg b/Lib/std/std_carray.swg index ebb20ce6a..de2a07627 100644 --- a/Lib/std/std_carray.swg +++ b/Lib/std/std_carray.swg @@ -28,8 +28,8 @@ namespace std { carray() { } - carray(const carray& c) { - std::copy(c.v, c.v + size(), v); + carray(const carray& other) { + std::copy(other.v, other.v + size(), v); } template diff --git a/Lib/tcl/std_map.i b/Lib/tcl/std_map.i index ce1381f03..2c7f40ac7 100644 --- a/Lib/tcl/std_map.i +++ b/Lib/tcl/std_map.i @@ -33,7 +33,7 @@ namespace std { typedef const value_type& const_reference; map(); - map(const map< K, T, C >& other); + map(const map& other); unsigned int size() const; bool empty() const; diff --git a/Lib/tcl/std_vector.i b/Lib/tcl/std_vector.i index bb227cf3d..5fba5379f 100644 --- a/Lib/tcl/std_vector.i +++ b/Lib/tcl/std_vector.i @@ -218,7 +218,7 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector< T >& other); + vector(const vector& other); unsigned int size() const; bool empty() const; @@ -377,7 +377,7 @@ namespace std { vector(unsigned int size = 0); vector(unsigned int size, const T& value); - vector(const vector< T >& other); + vector(const vector& other); unsigned int size() const; bool empty() const; From a6a50d60e170aeb7e1310c1ddf119fdff53560a6 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 14 Feb 2019 21:41:08 +0000 Subject: [PATCH 24/26] Restore original std::map template parameters for Java --- Lib/java/std_map.i | 72 ++++++++++++++++++------------------ Lib/java/std_unordered_map.i | 72 ++++++++++++++++++------------------ 2 files changed, 72 insertions(+), 72 deletions(-) diff --git a/Lib/java/std_map.i b/Lib/java/std_map.i index 357401a4d..4b891e74a 100644 --- a/Lib/java/std_map.i +++ b/Lib/java/std_map.i @@ -46,10 +46,10 @@ namespace std { -template > class map { +template > class map { -%typemap(javabase) std::map - "java.util.AbstractMap<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>" +%typemap(javabase) std::map< K, T, C > + "java.util.AbstractMap<$typemap(jboxtype, K), $typemap(jboxtype, T)>" %proxycode %{ @@ -58,19 +58,19 @@ template } public boolean containsKey(Object key) { - if (!(key instanceof $typemap(jboxtype, KeyType))) { + if (!(key instanceof $typemap(jboxtype, K))) { return false; } - return containsImpl(($typemap(jboxtype, KeyType))key); + return containsImpl(($typemap(jboxtype, K))key); } - public $typemap(jboxtype, MappedType) get(Object key) { - if (!(key instanceof $typemap(jboxtype, KeyType))) { + public $typemap(jboxtype, T) get(Object key) { + if (!(key instanceof $typemap(jboxtype, K))) { return null; } - Iterator itr = find(($typemap(jboxtype, KeyType)) key); + Iterator itr = find(($typemap(jboxtype, K)) key); if (itr.isNot(end())) { return itr.getValue(); } @@ -78,10 +78,10 @@ template return null; } - public $typemap(jboxtype, MappedType) put($typemap(jboxtype, KeyType) key, $typemap(jboxtype, MappedType) value) { - Iterator itr = find(($typemap(jboxtype, KeyType)) key); + public $typemap(jboxtype, T) put($typemap(jboxtype, K) key, $typemap(jboxtype, T) value) { + Iterator itr = find(($typemap(jboxtype, K)) key); if (itr.isNot(end())) { - $typemap(jboxtype, MappedType) oldValue = itr.getValue(); + $typemap(jboxtype, T) oldValue = itr.getValue(); itr.setValue(value); return oldValue; } else { @@ -90,14 +90,14 @@ template } } - public $typemap(jboxtype, MappedType) remove(Object key) { - if (!(key instanceof $typemap(jboxtype, KeyType))) { + public $typemap(jboxtype, T) remove(Object key) { + if (!(key instanceof $typemap(jboxtype, K))) { return null; } - Iterator itr = find(($typemap(jboxtype, KeyType)) key); + Iterator itr = find(($typemap(jboxtype, K)) key); if (itr.isNot(end())) { - $typemap(jboxtype, MappedType) oldValue = itr.getValue(); + $typemap(jboxtype, T) oldValue = itr.getValue(); removeUnchecked(itr); return oldValue; } else { @@ -105,31 +105,31 @@ template } } - public java.util.Set> entrySet() { - java.util.Set> setToReturn = - new java.util.HashSet>(); + public java.util.Set> entrySet() { + java.util.Set> setToReturn = + new java.util.HashSet>(); Iterator itr = begin(); final Iterator end = end(); while (itr.isNot(end)) { - setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>() { + setToReturn.add(new Entry<$typemap(jboxtype, K), $typemap(jboxtype, T)>() { private Iterator iterator; - private Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)> init(Iterator iterator) { + private Entry<$typemap(jboxtype, K), $typemap(jboxtype, T)> init(Iterator iterator) { this.iterator = iterator; return this; } - public $typemap(jboxtype, KeyType) getKey() { + public $typemap(jboxtype, K) getKey() { return iterator.getKey(); } - public $typemap(jboxtype, MappedType) getValue() { + public $typemap(jboxtype, T) getValue() { return iterator.getValue(); } - public $typemap(jboxtype, MappedType) setValue($typemap(jboxtype, MappedType) newValue) { - $typemap(jboxtype, MappedType) oldValue = iterator.getValue(); + public $typemap(jboxtype, T) setValue($typemap(jboxtype, T) newValue) { + $typemap(jboxtype, T) oldValue = iterator.getValue(); iterator.setValue(newValue); return oldValue; } @@ -144,9 +144,9 @@ template public: typedef size_t size_type; typedef ptrdiff_t difference_type; - typedef KeyType key_type; - typedef MappedType mapped_type; - typedef std::pair< const KeyType, MappedType > value_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; @@ -158,8 +158,8 @@ template struct iterator { %typemap(javaclassmodifiers) iterator "protected class" %extend { - std::map::iterator getNextUnchecked() { - std::map::iterator copy = (*$self); + std::map< K, T, C >::iterator getNextUnchecked() { + std::map< K, T, C >::iterator copy = (*$self); return ++copy; } @@ -167,15 +167,15 @@ template return (*$self != other); } - KeyType getKey() const { + K getKey() const { return (*$self)->first; } - MappedType getValue() const { + T getValue() const { return (*$self)->second; } - void setValue(const MappedType& newValue) { + void setValue(const T& newValue) { (*$self)->second = newValue; } } @@ -184,7 +184,7 @@ template %rename(isEmpty) empty; bool empty() const; void clear(); - iterator find(const KeyType& key); + iterator find(const K& key); iterator begin(); iterator end(); %extend { @@ -194,15 +194,15 @@ template return SWIG_MapSize(self->size()); } - bool containsImpl(const KeyType& key) { + bool containsImpl(const K& key) { return (self->count(key) > 0); } - void putUnchecked(const KeyType& key, const MappedType& value) { + void putUnchecked(const K& key, const T& value) { (*self)[key] = value; } - void removeUnchecked(const std::map::iterator itr) { + void removeUnchecked(const std::map< K, T, C >::iterator itr) { self->erase(itr); } } diff --git a/Lib/java/std_unordered_map.i b/Lib/java/std_unordered_map.i index 57ebe4e39..8f62d7290 100644 --- a/Lib/java/std_unordered_map.i +++ b/Lib/java/std_unordered_map.i @@ -46,10 +46,10 @@ namespace std { -template class unordered_map { +template class unordered_map { -%typemap(javabase) std::unordered_map - "java.util.AbstractMap<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>" +%typemap(javabase) std::unordered_map + "java.util.AbstractMap<$typemap(jboxtype, K), $typemap(jboxtype, T)>" %proxycode %{ @@ -58,19 +58,19 @@ template class unordered_map { } public boolean containsKey(Object key) { - if (!(key instanceof $typemap(jboxtype, KeyType))) { + if (!(key instanceof $typemap(jboxtype, K))) { return false; } - return containsImpl(($typemap(jboxtype, KeyType))key); + return containsImpl(($typemap(jboxtype, K))key); } - public $typemap(jboxtype, MappedType) get(Object key) { - if (!(key instanceof $typemap(jboxtype, KeyType))) { + public $typemap(jboxtype, T) get(Object key) { + if (!(key instanceof $typemap(jboxtype, K))) { return null; } - Iterator itr = find(($typemap(jboxtype, KeyType)) key); + Iterator itr = find(($typemap(jboxtype, K)) key); if (itr.isNot(end())) { return itr.getValue(); } @@ -78,10 +78,10 @@ template class unordered_map { return null; } - public $typemap(jboxtype, MappedType) put($typemap(jboxtype, KeyType) key, $typemap(jboxtype, MappedType) value) { - Iterator itr = find(($typemap(jboxtype, KeyType)) key); + public $typemap(jboxtype, T) put($typemap(jboxtype, K) key, $typemap(jboxtype, T) value) { + Iterator itr = find(($typemap(jboxtype, K)) key); if (itr.isNot(end())) { - $typemap(jboxtype, MappedType) oldValue = itr.getValue(); + $typemap(jboxtype, T) oldValue = itr.getValue(); itr.setValue(value); return oldValue; } else { @@ -90,14 +90,14 @@ template class unordered_map { } } - public $typemap(jboxtype, MappedType) remove(Object key) { - if (!(key instanceof $typemap(jboxtype, KeyType))) { + public $typemap(jboxtype, T) remove(Object key) { + if (!(key instanceof $typemap(jboxtype, K))) { return null; } - Iterator itr = find(($typemap(jboxtype, KeyType)) key); + Iterator itr = find(($typemap(jboxtype, K)) key); if (itr.isNot(end())) { - $typemap(jboxtype, MappedType) oldValue = itr.getValue(); + $typemap(jboxtype, T) oldValue = itr.getValue(); removeUnchecked(itr); return oldValue; } else { @@ -105,31 +105,31 @@ template class unordered_map { } } - public java.util.Set> entrySet() { - java.util.Set> setToReturn = - new java.util.HashSet>(); + public java.util.Set> entrySet() { + java.util.Set> setToReturn = + new java.util.HashSet>(); Iterator itr = begin(); final Iterator end = end(); while (itr.isNot(end)) { - setToReturn.add(new Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)>() { + setToReturn.add(new Entry<$typemap(jboxtype, K), $typemap(jboxtype, T)>() { private Iterator iterator; - private Entry<$typemap(jboxtype, KeyType), $typemap(jboxtype, MappedType)> init(Iterator iterator) { + private Entry<$typemap(jboxtype, K), $typemap(jboxtype, T)> init(Iterator iterator) { this.iterator = iterator; return this; } - public $typemap(jboxtype, KeyType) getKey() { + public $typemap(jboxtype, K) getKey() { return iterator.getKey(); } - public $typemap(jboxtype, MappedType) getValue() { + public $typemap(jboxtype, T) getValue() { return iterator.getValue(); } - public $typemap(jboxtype, MappedType) setValue($typemap(jboxtype, MappedType) newValue) { - $typemap(jboxtype, MappedType) oldValue = iterator.getValue(); + public $typemap(jboxtype, T) setValue($typemap(jboxtype, T) newValue) { + $typemap(jboxtype, T) oldValue = iterator.getValue(); iterator.setValue(newValue); return oldValue; } @@ -144,9 +144,9 @@ template class unordered_map { public: typedef size_t size_type; typedef ptrdiff_t difference_type; - typedef KeyType key_type; - typedef MappedType mapped_type; - typedef std::pair< const KeyType, MappedType > value_type; + typedef K key_type; + typedef T mapped_type; + typedef std::pair< const K, T > value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; @@ -158,8 +158,8 @@ template class unordered_map { struct iterator { %typemap(javaclassmodifiers) iterator "protected class" %extend { - std::unordered_map::iterator getNextUnchecked() { - std::unordered_map::iterator copy = (*$self); + std::unordered_map< K, T >::iterator getNextUnchecked() { + std::unordered_map< K, T >::iterator copy = (*$self); return ++copy; } @@ -167,15 +167,15 @@ template class unordered_map { return (*$self != other); } - KeyType getKey() const { + K getKey() const { return (*$self)->first; } - MappedType getValue() const { + T getValue() const { return (*$self)->second; } - void setValue(const MappedType& newValue) { + void setValue(const T& newValue) { (*$self)->second = newValue; } } @@ -184,7 +184,7 @@ template class unordered_map { %rename(isEmpty) empty; bool empty() const; void clear(); - iterator find(const KeyType& key); + iterator find(const K& key); iterator begin(); iterator end(); %extend { @@ -194,15 +194,15 @@ template class unordered_map { return SWIG_MapSize(self->size()); } - bool containsImpl(const KeyType& key) { + bool containsImpl(const K& key) { return (self->count(key) > 0); } - void putUnchecked(const KeyType& key, const MappedType& value) { + void putUnchecked(const K& key, const T& value) { (*self)[key] = value; } - void removeUnchecked(const std::unordered_map::iterator itr) { + void removeUnchecked(const std::unordered_map< K, T >::iterator itr) { self->erase(itr); } } From 52063a732b0133a18819d866d8ecd5facdff1ede Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 14 Feb 2019 21:57:26 +0000 Subject: [PATCH 25/26] Consistent parameter names for std::pair --- Lib/csharp/std_pair.i | 6 +++--- Lib/d/std_pair.i | 6 +++--- Lib/go/std_pair.i | 4 ++-- Lib/guile/std_pair.i | 16 ++++++++-------- Lib/java/std_pair.i | 4 ++-- Lib/javascript/jsc/std_pair.i | 4 ++-- Lib/javascript/v8/std_pair.i | 4 ++-- Lib/lua/std_pair.i | 4 ++-- Lib/mzscheme/std_pair.i | 16 ++++++++-------- Lib/ocaml/std_pair.i | 4 ++-- Lib/perl5/std_pair.i | 6 +++--- Lib/php/std_pair.i | 4 ++-- Lib/scilab/std_pair.i | 4 ++-- Lib/std/std_pair.i | 16 ++++++++-------- Lib/tcl/std_pair.i | 4 ++-- 15 files changed, 51 insertions(+), 51 deletions(-) diff --git a/Lib/csharp/std_pair.i b/Lib/csharp/std_pair.i index 932849017..732347db5 100644 --- a/Lib/csharp/std_pair.i +++ b/Lib/csharp/std_pair.i @@ -22,10 +22,10 @@ namespace std { typedef U second_type; pair(); - pair(T t, U u); - pair(const pair& p); + pair(T first, U second); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/d/std_pair.i b/Lib/d/std_pair.i index 932849017..732347db5 100644 --- a/Lib/d/std_pair.i +++ b/Lib/d/std_pair.i @@ -22,10 +22,10 @@ namespace std { typedef U second_type; pair(); - pair(T t, U u); - pair(const pair& p); + pair(T first, U second); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/go/std_pair.i b/Lib/go/std_pair.i index 867bb2cd5..732347db5 100644 --- a/Lib/go/std_pair.i +++ b/Lib/go/std_pair.i @@ -23,9 +23,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/guile/std_pair.i b/Lib/guile/std_pair.i index e738ecec9..050d4880a 100644 --- a/Lib/guile/std_pair.i +++ b/Lib/guile/std_pair.i @@ -119,9 +119,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; @@ -221,9 +221,9 @@ namespace std { } pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; @@ -321,9 +321,9 @@ namespace std { } pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; @@ -412,9 +412,9 @@ namespace std { } pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/java/std_pair.i b/Lib/java/std_pair.i index 1454eaa9c..75ad30315 100644 --- a/Lib/java/std_pair.i +++ b/Lib/java/std_pair.i @@ -24,9 +24,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/javascript/jsc/std_pair.i b/Lib/javascript/jsc/std_pair.i index 867bb2cd5..732347db5 100644 --- a/Lib/javascript/jsc/std_pair.i +++ b/Lib/javascript/jsc/std_pair.i @@ -23,9 +23,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/javascript/v8/std_pair.i b/Lib/javascript/v8/std_pair.i index 7530e374e..b72c50b99 100644 --- a/Lib/javascript/v8/std_pair.i +++ b/Lib/javascript/v8/std_pair.i @@ -22,9 +22,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/lua/std_pair.i b/Lib/lua/std_pair.i index 558887789..410da9223 100644 --- a/Lib/lua/std_pair.i +++ b/Lib/lua/std_pair.i @@ -15,12 +15,12 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); T first; U second; }; template - pair make_pair(const T& t,const U& u); + pair make_pair(const T& first, const U& second); } diff --git a/Lib/mzscheme/std_pair.i b/Lib/mzscheme/std_pair.i index 52d2bdf87..75f6751cc 100644 --- a/Lib/mzscheme/std_pair.i +++ b/Lib/mzscheme/std_pair.i @@ -121,9 +121,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; @@ -223,9 +223,9 @@ namespace std { } pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; @@ -324,9 +324,9 @@ namespace std { } pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; @@ -419,9 +419,9 @@ namespace std { } pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/ocaml/std_pair.i b/Lib/ocaml/std_pair.i index 867bb2cd5..732347db5 100644 --- a/Lib/ocaml/std_pair.i +++ b/Lib/ocaml/std_pair.i @@ -23,9 +23,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/perl5/std_pair.i b/Lib/perl5/std_pair.i index 932849017..732347db5 100644 --- a/Lib/perl5/std_pair.i +++ b/Lib/perl5/std_pair.i @@ -22,10 +22,10 @@ namespace std { typedef U second_type; pair(); - pair(T t, U u); - pair(const pair& p); + pair(T first, U second); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/php/std_pair.i b/Lib/php/std_pair.i index 867bb2cd5..732347db5 100644 --- a/Lib/php/std_pair.i +++ b/Lib/php/std_pair.i @@ -23,9 +23,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/scilab/std_pair.i b/Lib/scilab/std_pair.i index bd0eb53fe..39ef008d3 100644 --- a/Lib/scilab/std_pair.i +++ b/Lib/scilab/std_pair.i @@ -23,9 +23,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; diff --git a/Lib/std/std_pair.i b/Lib/std/std_pair.i index 001cd6738..800155f21 100644 --- a/Lib/std/std_pair.i +++ b/Lib/std/std_pair.i @@ -35,9 +35,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair< U1, U2 > &p); + template pair(const pair< U1, U2 > &other); T first; U second; @@ -76,8 +76,8 @@ namespace std { %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T, U* >); pair(); - pair(T __a, U* __b); - pair(const pair& __p); + pair(T first, U* second); + pair(const pair& other); T first; U* second; @@ -112,8 +112,8 @@ namespace std { %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T*, U >); pair(); - pair(T* __a, U __b); - pair(const pair& __p); + pair(T* first, U second); + pair(const pair& other); T* first; U second; @@ -148,8 +148,8 @@ namespace std { %typemap_traits(SWIG_TYPECHECK_PAIR, std::pair< T*, U* >); pair(); - pair(T* __a, U* __b); - pair(const pair& __p); + pair(T* first, U* second); + pair(const pair& other); T* first; U* second; diff --git a/Lib/tcl/std_pair.i b/Lib/tcl/std_pair.i index bd0eb53fe..39ef008d3 100644 --- a/Lib/tcl/std_pair.i +++ b/Lib/tcl/std_pair.i @@ -23,9 +23,9 @@ namespace std { pair(); pair(T first, U second); - pair(const pair& p); + pair(const pair& other); - template pair(const pair &p); + template pair(const pair &other); T first; U second; From 7b0402f89bb034a60041c1330dcc62ff6b5cc95a Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 14 Feb 2019 22:46:20 +0000 Subject: [PATCH 26/26] Changes file entry for Java STL support --- CHANGES.current | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/CHANGES.current b/CHANGES.current index 5bc2b4982..91f63e6da 100644 --- a/CHANGES.current +++ b/CHANGES.current @@ -7,6 +7,44 @@ the issue number to the end of the URL: https://github.com/swig/swig/issues/ Version 4.0.0 (in progress) =========================== +2019-02-14: wsfulton + Add some missing copy constructors into STL containers. + +2019-02-14: bkotzz + [Java] #1356 Add STL containers: + std::unordered_map + std::unordered_set + std::set + +2019-02-14: bkotzz + [Java] #1356 std::map wrappers have been modified. Now the Java proxy class + extends java.util.AbstractMap. The std::map container looks and feels much like + a java.util.HashMap from Java. + + A few members have changed their names. If the old method signatures are needed, + then copy std_map.i from swig-3.0.12 and use that instead. Alternatively, + add the old missing methods to the new methods by using the following %proxycode: + + %extend std::map { + %proxycode %{ + // Old API + public boolean empty() { + return isEmpty(); + } + public void set($typemap(jboxtype, K) key, $typemap(jboxtype, T) x) { + put(key, x); + } + public void del($typemap(jboxtype, K) key) { + remove(key); + } + public boolean has_key($typemap(jboxtype, K) key) { + return containsKey(key); + } + %} + } + + *** POTENTIAL INCOMPATIBILITY *** + 2019-02-11: wsfulton [OCaml] #1437 OCaml has been give the 'Experimental' language status. The examples work and most of the test-suite is also working, so it is quite close to being a 'Supported' language.