From 573ddb061e86541326ef1ff3256af65ff70c7afe Mon Sep 17 00:00:00 2001 From: Brad Kotsopoulos Date: Thu, 27 Dec 2018 01:11:54 -0500 Subject: [PATCH] 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 +}