# Subclasses often provide a more efficient implementation.
#
# Because of the `iterator` method, Collections instances can use
-# the `for` control structure:
+# the `for` control structure.
#
-# var x: Collection[U]
-# # ...
-# for u in x do
-# # u is a U
-# # ...
-# end
+# ~~~nitish
+# var x: Collection[U]
+# # ...
+# for u in x do
+# # u is a U
+# # ...
+# end
+# ~~~
#
-# that is equivalent with
+# that is equivalent with the following:
#
-# var x: Collection[U]
-# # ...
-# var i = x.iterator
-# while i.is_ok do
-# var u = i.item # u is a U
-# # ...
-# i.next
-# end
+# ~~~nitish
+# var x: Collection[U]
+# # ...
+# var i = x.iterator
+# while i.is_ok do
+# var u = i.item # u is a U
+# # ...
+# i.next
+# end
+# ~~~
interface Collection[E]
# Get a new iterator on the collection.
fun iterator: Iterator[E] is abstract
# How many occurrences of `item` are in the collection?
# Comparisons are done with ==
#
- # assert [10,20,10].count(10) == 2
+ # assert [10,20,10].count(10) == 2
fun count(item: E): Int
do
var nb = 0
# Return the first item of the collection
#
- # assert [1,2,3].first == 1
+ # assert [1,2,3].first == 1
fun first: E
do
assert length > 0
return iterator.item
end
- # Is the collection contains all the elements of `other`?
+ # Does the collection contain at least each element of `other`?
+ #
+ # assert [1,3,4,2].has_all([1..2]) == true
+ # assert [1,3,4,2].has_all([1..5]) == false
+ #
+ # Repeated elements in the collections are not considered.
+ #
+ # assert [1,1,1].has_all([1]) == true
+ # assert [1..5].has_all([1,1,1]) == true
#
- # assert [1,1,1].has_all([1]) == true
- # assert [1,1,1].has_all([1,2]) == false
- # assert [1,3,4,2].has_all([1..2]) == true
- # assert [1,3,4,2].has_all([1..5]) == false
+ # Note that the default implementation is general and correct for any lawful Collections.
+ # It is memory-efficient but relies on `has` so may be CPU-inefficient for some kind of collections.
fun has_all(other: Collection[E]): Bool
do
for x in other do if not has(x) then return false
return true
end
+
+ # Does the collection contain exactly all the elements of `other`?
+ #
+ # The same elements must be present in both `self` and `other`,
+ # but the order of the elements in the collections are not considered.
+ #
+ # assert [1..3].has_exactly([3,1,2]) == true # the same elements
+ # assert [1..3].has_exactly([3,1]) == false # 2 is not in the array
+ # assert [1..2].has_exactly([3,1,2]) == false # 3 is not in the range
+ #
+ # Repeated elements must be present in both collections in the same amount.
+ # So basically it is a multi-set comparison.
+ #
+ # assert [1,2,3,2].has_exactly([1,2,2,3]) == true # the same elements
+ # assert [1,2,3,2].has_exactly([1,2,3]) == false # more 2 in the first array
+ # assert [1,2,3].has_exactly([1,2,2,3]) == false # more 2 in the second array
+ #
+ # Note that the default implementation is general and correct for any lawful Collections.
+ # It is memory-efficient but relies on `count` so may be CPU-inefficient for some kind of collections.
+ fun has_exactly(other: Collection[E]): Bool
+ do
+ if length != other.length then return false
+ for e in self do if self.count(e) != other.count(e) then return false
+ return true
+ end
end
# Instances of the Iterator class generates a series of elements, one at a time.
redef var is_ok: Bool = true
- private var container: Container[E]
+ var container: Container[E]
end
# Items can be removed from this collection
return nhs
end
+ # Returns a new instance of `Set`.
+ #
+ # Depends on the subclass, mainly used for copy services
+ # like `union` or `intersection`.
protected fun new_set: Set[E] is abstract
end
# MapRead are abstract associative collections: `key` -> `item`.
-interface MapRead[K: Object, V]
+interface MapRead[K, V]
# Get the item at `key`
#
# var x = new HashMap[String, Int]
# assert map.values.has(1) == true
# assert map.values.has(3) == false
#
-interface Map[K: Object, V]
+interface Map[K, V]
super MapRead[K, V]
# Set the `value` at `key`.
end
# Iterators for Map.
-interface MapIterator[K: Object, V]
+interface MapIterator[K, V]
# The current item.
# Require `is_ok`.
fun item: V is abstract
end
# Iterator on a 'keys' point of view of a map
-class MapKeysIterator[K: Object, V]
+class MapKeysIterator[K, V]
super Iterator[K]
# The original iterator
var original_iterator: MapIterator[K, V]
end
# Iterator on a 'values' point of view of a map
-class MapValuesIterator[K: Object, V]
+class MapValuesIterator[K, V]
super Iterator[V]
# The original iterator
var original_iterator: MapIterator[K, V]
# Associative arrays that internally uses couples to represent each (key, value) pairs.
# This is an helper class that some specific implementation of Map may implements.
-interface CoupleMap[K: Object, V]
+interface CoupleMap[K, V]
super Map[K, V]
# Return the couple of the corresponding key
# Iterator on CoupleMap
#
# Actually it is a wrapper around an iterator of the internal array of the map.
-private class CoupleMapIterator[K: Object, V]
+private class CoupleMapIterator[K, V]
super MapIterator[K, V]
redef fun item do return _iter.item.second
_iter.next
end
- private var iter: Iterator[Couple[K,V]]
+ var iter: Iterator[Couple[K,V]]
end
# Some tools ###################################################################