lib: removals on Map are done on the views (keys and values)

Thus depreciate some methods in Map
remove_at -> keys.remove
remove -> values.remove
remove_all -> values.remove_all

Signed-off-by: Jean Privat <jean@pryen.org>

diff --git a/lib/standard/collection/abstract_collection.nit b/lib/standard/collection/abstract_collection.nit
index 64fdac4..b164060 100644 (file)
--- a/lib/standard/collection/abstract_collection.nit
+++ b/lib/standard/collection/abstract_collection.nit
@@ -301,8 +301,8 @@ interface Map[K: Object, E]
        # Set the`item' at `key'.
        fun []=(key: K, item: E) is abstract
 
-       # Remove the item at `key'
-       fun remove_at(key: K) is abstract
+       # Depreciated alias for `keys.remove`
+       fun remove_at(key: K) do keys.remove(key)
 
        # Add each (key,value) of `map' into `self'.
        # If a same key exists in `map' and `self', then the value in self is discarded.
@@ -318,11 +318,15 @@ interface Map[K: Object, E]
        # Remove all items
        fun clear is abstract
 
-       # Remove an occucence of `item'
-       fun remove(item: E) is abstract
+       # Depreciated alias for `values.remove`
+       fun remove(item: E) do values.remove(item)
 
-       # Remove all occurences of `item'
-       fun remove_all(item: E) do while has(item) do remove(item)
+       # Depreciated alias for `values.remove_all`
+       fun remove_all(item: E) do values.remove_all(item)
+
+       redef fun values: RemovableCollection[E] is abstract
+
+       redef fun keys: RemovableCollection[E] is abstract
 end
 
 # Iterators for Map.

diff --git a/lib/standard/collection/array.nit b/lib/standard/collection/array.nit
index 8a11c88..8db629b 100644 (file)
--- a/lib/standard/collection/array.nit
+++ b/lib/standard/collection/array.nit
@@ -510,35 +510,6 @@ class ArrayMap[K: Object, E]
 
        redef fun is_empty do return _items.is_empty
 
-       redef fun remove(item)
-       do
-               var i = _items.length - 1
-               while i >= 0 do
-                       if _items[i].second == item then
-                               remove_at_index(i)
-                               return
-                       end
-                       i -= 1
-               end
-       end
-
-       redef fun remove_all(item: E)
-       do
-               var i = _items.length - 1
-               while i >= 0 do
-                       if _items[i].second == item then
-                               remove_at_index(i)
-                       end
-                       i -= 1
-               end
-       end
-
-       redef fun remove_at(key)
-       do
-               var i = index(key)
-               if i >= 0 then remove_at_index(i)
-       end
-
        redef fun clear do _items.clear
 
        # Assume the capacity to be at least `cap'.
@@ -593,7 +564,7 @@ class ArrayMap[K: Object, E]
 end
 
 class ArrayMapKeys[K: Object, E]
-       super Collection[K]
+       super RemovableCollection[K]
        # The original map
        var map: ArrayMap[K, E]
        redef fun count(k) do if self.has(k) then return 1 else return 0
@@ -603,10 +574,17 @@ class ArrayMapKeys[K: Object, E]
        redef fun is_empty do return self.map.is_empty
        redef fun length do return self.map.length
        redef fun iterator do return new MapKeysIterator[K, E](self.map.iterator)
+       redef fun clear do self.map.clear
+       redef fun remove(key)
+       do
+               var i = self.map.index(key)
+               if i >= 0 then self.map.remove_at_index(i)
+       end
+       redef fun remove_all(key) do self.remove(key)
 end
 
 class ArrayMapValues[K: Object, E]
-       super Collection[K]
+       super RemovableCollection[K]
        # The original map
        var map: ArrayMap[K, E]
        redef fun first do return self.map._items.first.first
@@ -636,6 +614,32 @@ class ArrayMapValues[K: Object, E]
                return nb
        end
 
+       redef fun clear do self.map.clear
+
+       redef fun remove(item)
+       do
+               var map = self.map
+               var i = map._items.length - 1
+               while i >= 0 do
+                       if map._items[i].second == item then
+                               map.remove_at_index(i)
+                               return
+                       end
+                       i -= 1
+               end
+       end
+
+       redef fun remove_all(item)
+       do
+               var map = self.map
+               var i = map._items.length - 1
+               while i >= 0 do
+                       if map._items[i].second == item then
+                               map.remove_at_index(i)
+                       end
+                       i -= 1
+               end
+       end
 end
 
 

diff --git a/lib/standard/collection/hash_collection.nit b/lib/standard/collection/hash_collection.nit
index 11dfa61..07bc985 100644 (file)
--- a/lib/standard/collection/hash_collection.nit
+++ b/lib/standard/collection/hash_collection.nit
@@ -238,20 +238,6 @@ class HashMap[K: Object, V]
                end
        end
 
-       redef fun remove(item)
-       do
-               var c = _first_item
-               while c != null do
-                       if c._value == item then
-                               remove_node(c._key)
-                               return
-                       end
-                       c = c._next_item
-               end
-       end
-
-       redef fun remove_at(key) do remove_node(key)
-
        redef fun clear do raz
 
        init
@@ -266,7 +252,7 @@ class HashMap[K: Object, V]
 end
 
 class HashMapKeys[K: Object, V]
-       super NaiveCollection[K]
+       super RemovableCollection[K]
        # The original map
        var map: HashMap[K, V]
 
@@ -278,10 +264,15 @@ class HashMapKeys[K: Object, V]
        redef fun length do return self.map.length
 
        redef fun iterator do return new MapKeysIterator[K, V](self.map.iterator)
+
+       redef fun clear do self.map.clear
+
+       redef fun remove(key) do self.map.remove_node(key)
+       redef fun remove_all(key) do self.map.remove_node(key)
 end
 
 class HashMapValues[K: Object, V]
-       super NaiveCollection[V]
+       super RemovableCollection[V]
        # The original map
        var map: HashMap[K, V]
 
@@ -321,6 +312,33 @@ class HashMapValues[K: Object, V]
        redef fun length do return self.map.length
 
        redef fun iterator do return new MapValuesIterator[K, V](self.map.iterator)
+
+       redef fun clear do self.map.clear
+
+       redef fun remove(item)
+       do
+               var map = self.map
+               var c = map._first_item
+               while c != null do
+                       if c._value == item then
+                               map.remove_node(c._key)
+                               return
+                       end
+                       c = c._next_item
+               end
+       end
+
+       redef fun remove_all(item)
+       do
+               var map = self.map
+               var c = map._first_item
+               while c != null do
+                       if c._value == item then
+                               map.remove_node(c._key)
+                       end
+                       c = c._next_item
+               end
+       end
 end
 
 class HashMapNode[K: Object, V]