lib: add 'keys' and 'values' methods in Map

[nit.git] / lib / standard / collection / array.nit

diff --git a/lib/standard/collection/array.nit b/lib/standard/collection/array.nit
index 86357ae..8a11c88 100644 (file)
--- a/lib/standard/collection/array.nit
+++ b/lib/standard/collection/array.nit
@@ -19,7 +19,7 @@ import abstract_collection
 
 # One dimention array of objects.
 class AbstractArrayRead[E]
-special SequenceRead[E]
+       super SequenceRead[E]
        # The current length
        redef readable var _length: Int = 0
 
@@ -47,8 +47,6 @@ special SequenceRead[E]
                return true
        end
 
-       redef fun has_key(index) do return index >= 0 and index < length
-
        redef fun count(item)
        do
                var res = 0
@@ -142,8 +140,8 @@ end
 
 # Resizeable one dimention array of objects.
 class AbstractArray[E]
-special AbstractArrayRead[E]
-special Sequence[E]
+       super AbstractArrayRead[E]
+       super Sequence[E]
        fun enlarge(cap: Int) is abstract
 
        redef fun push(item) do add(item)
@@ -226,8 +224,8 @@ end
 #     a.push(32)
 #     a.push(8)
 class Array[E]
-special AbstractArray[E]
-special ArrayCapable[E]
+       super AbstractArray[E]
+       super ArrayCapable[E]
        redef fun iterate
                !each(e: E)
        do
@@ -391,7 +389,7 @@ end
 
 # An `Iterator' on `AbstractArray'
 class ArrayIterator[E]
-special IndexedIterator[E]
+       super IndexedIterator[E]
        redef fun item do return _array[_index]
 
        # redef fun item=(e) do _array[_index] = e
@@ -414,7 +412,7 @@ end
 
 # A set implemented with an Array.
 class ArraySet[E: Object]
-special Set[E]
+       super Set[E]
        # The stored elements.
        var _array: Array[E]
 
@@ -462,7 +460,7 @@ end
 
 # Iterators on sets implemented with arrays.
 class ArraySetIterator[E: Object]
-special Iterator[E]
+       super Iterator[E]
 
        redef fun is_ok do return _iter.is_ok
 
@@ -478,7 +476,7 @@ end
 
 # Associative arrays implemented with an array of (key, value) pairs.
 class ArrayMap[K: Object, E]
-special CoupleMap[K, E]
+       super CoupleMap[K, E]
 
        # O(n)
        redef fun [](key)
@@ -502,36 +500,12 @@ special CoupleMap[K, E]
                end
        end
 
-       # O(n)
-       redef fun has_key(key) do return index(key) >= 0
-
-       # O(n)
-       redef fun has(item)
-       do
-               for i in _items do if i.second == item then return true
-               return false
-       end
-
-       # O(n)
-       redef fun has_only(item)
-       do
-               for i in _items do if i.second != item then return false
-               return true
-       end
+       redef var keys: ArrayMapKeys[K, E] = new ArrayMapKeys[K, E](self)
+       redef var values: ArrayMapValues[K, E] = new ArrayMapValues[K, E](self)
 
        # O(1)
        redef fun length do return _items.length
 
-       redef fun first do return _items.first.second
-
-       # O(n)
-       redef fun count(item)
-       do
-               var nb = 0
-               for i in _items do if i.second == item then nb += 1
-               return nb
-       end
-
        redef fun iterator: CoupleMapIterator[K, E] do return new CoupleMapIterator[K, E](_items.iterator)
 
        redef fun is_empty do return _items.is_empty
@@ -618,6 +592,53 @@ special CoupleMap[K, E]
        end
 end
 
+class ArrayMapKeys[K: Object, E]
+       super Collection[K]
+       # The original map
+       var map: ArrayMap[K, E]
+       redef fun count(k) do if self.has(k) then return 1 else return 0
+       redef fun first do return self.map._items.first.first
+       redef fun has(k) do return self.map.index(k) >= 0
+       redef fun has_only(k) do return (self.has(k) and self.length == 1) or self.is_empty
+       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)
+end
+
+class ArrayMapValues[K: Object, E]
+       super Collection[K]
+       # The original map
+       var map: ArrayMap[K, E]
+       redef fun first do return self.map._items.first.first
+       redef fun is_empty do return self.map.is_empty
+       redef fun length do return self.map.length
+       redef fun iterator do return new MapValuesIterator[K, E](self.map.iterator)
+
+       # O(n)
+       redef fun has(item)
+       do
+               for i in self.map._items do if i.second == item then return true
+               return false
+       end
+
+       # O(n)
+       redef fun has_only(item)
+       do
+               for i in self.map._items do if i.second != item then return false
+               return true
+       end
+
+       # O(n)
+       redef fun count(item)
+       do
+               var nb = 0
+               for i in self.map._items do if i.second == item then nb += 1
+               return nb
+       end
+
+end
+
+
 # Others tools ################################################################
 
 redef class Iterator[E]