1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Copyright 2004-2008 Jean Privat <jean@pryen.org>
5 # This file is free software, which comes along with NIT. This software is
6 # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
7 # without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
8 # PARTICULAR PURPOSE. You can modify it is you want, provided this header
9 # is kept unaltered, and a notification of the changes is added.
10 # You are allowed to redistribute it and sell it, alone or is a part of
13 # This module define several abstract collection classes.
14 module abstract_collection
18 # The root of the collection hierarchy.
20 # Collections modelize finite groups of objects, called elements.
22 # The specific behavior and representation of collections is determined
23 # by the subclasses of the hierarchy.
25 # The main service of Collection is to provide a stable `iterator`
26 # method usable to retrieve all the elements of the collection.
28 # Additional services are provided.
29 # For an implementation point of view, Collection provide a basic
30 # implementation of these services using the `iterator` method.
31 # Subclasses often provide a more efficient implementation.
33 # Because of the `iterator` method, Collections instances can use
34 # the `for` control structure:
36 # var x: Collection[U]
43 # that is equivalent with
45 # var x: Collection[U]
49 # var u = i.item # u is a U
53 interface Collection[E
]
54 # Get a new iterator on the collection.
55 fun iterator
: Iterator[E
] is abstract
57 # Is there no item in the collection?
59 # assert [1,2,3].is_empty == false
60 # assert [1..1[.is_empty == true
61 fun is_empty
: Bool do return length
== 0
63 # Number of items in the collection.
65 # assert [10,20,30].length == 3
66 # assert [20..30[.length == 10
70 for i
in self do nb
+= 1
75 # Is `item` in the collection ?
76 # Comparisons are done with ==
78 # assert [1,2,3].has(2) == true
79 # assert [1,2,3].has(9) == false
80 # assert [1..5[.has(2) == true
81 # assert [1..5[.has(9) == false
82 fun has
(item
: E
): Bool
84 for i
in self do if i
== item
then return true
88 # Is the collection contain only `item`?
89 # Comparisons are done with ==
90 # Return true if the collection is empty.
92 # assert [1,1,1].has_only(1) == true
93 # assert [1,2,3].has_only(1) == false
94 # assert [1..1].has_only(1) == true
95 # assert [1..3].has_only(1) == false
96 # assert [3..3[.has_only(1) == true # empty collection
98 # ENSURE `is_empty implies result == true`
99 fun has_only
(item
: E
): Bool
101 for i
in self do if i
!= item
then return false
105 # How many occurrences of `item` are in the collection?
106 # Comparisons are done with ==
108 # assert [10,20,10].count(10) == 2
109 fun count
(item
: E
): Int
112 for i
in self do if i
== item
then nb
+= 1
116 # Return the first item of the collection
118 # assert [1,2,3].first == 1
125 # Is the collection contains all the elements of `other`?
127 # assert [1,1,1].has_all([1]) == true
128 # assert [1,1,1].has_all([1,2]) == false
129 # assert [1,3,4,2].has_all([1..2]) == true
130 # assert [1,3,4,2].has_all([1..5]) == false
131 fun has_all
(other
: Collection[E
]): Bool
133 for x
in other
do if not has
(x
) then return false
138 # Instances of the Iterator class generates a series of elements, one at a time.
139 # They are mainly used with collections.
140 interface Iterator[E
]
143 fun item
: E
is abstract
145 # Jump to the next item.
149 # Is there a current item ?
150 fun is_ok
: Bool is abstract
153 # A collection that contains only one item.
154 # Used to pass arguments by reference
158 redef fun first
do return _item
160 redef fun is_empty
do return false
162 redef fun length
do return 1
164 redef fun has
(an_item
) do return _item
== an_item
166 redef fun has_only
(an_item
) do return _item
== an_item
168 redef fun count
(an_item
)
170 if _item
== an_item
then
177 redef fun iterator
do return new ContainerIterator[E
](self)
179 # Create a new instance with a given initial value.
180 init(e
: E
) do _item
= e
183 readable writable var _item
: E
186 # This iterator is quite stupid since it is used for only one item.
187 class ContainerIterator[E
]
189 redef fun item
do return _container
.item
191 redef fun next
do _is_ok
= false
193 init(c
: Container[E
]) do _container
= c
195 redef readable var _is_ok
: Bool = true
197 var _container
: Container[E
]
200 # Items can be removed from this collection
201 interface RemovableCollection[E
]
204 fun clear
is abstract
206 # Remove an occucence of `item`
207 fun remove
(item
: E
) is abstract
209 # Remove all occurences of `item`
210 fun remove_all
(item
: E
) do while has
(item
) do remove
(item
)
213 # Items can be added to these collections.
214 interface SimpleCollection[E
]
215 super RemovableCollection[E
]
216 # Add an item in a collection.
217 # Ensure col.has(item)
218 fun add
(item
: E
) is abstract
220 # Add each item of `coll`.
221 fun add_all
(coll
: Collection[E
]) do for i
in coll
do add
(i
)
226 # Set is a collection without ducplicates (according to ==)
227 # var s: Set[String] = new ArraySet[String]
229 # var b = "Hel" + "lo"
232 # assert s.has(b) == true
233 interface Set[E
: Object]
234 super SimpleCollection[E
]
236 redef fun has_only
(item
)
249 redef fun count
(item
)
258 # Synonym of remove since there is only one item
259 redef fun remove_all
(item
) do remove
(item
)
261 # Equality is defined on set and means that each set contains the same elements
264 if not other
isa Set[Object] then return false
265 if other
.length
!= length
then return false
266 return has_all
(other
)
269 # because of the law between `==` and `hash`, hash is redefined to be the sum of the hash of the elements
273 for e
in self do res
+= res
.hash
278 # MapRead are abstract associative collections: `key` -> `item`.
279 interface MapRead[K
: Object, E
]
280 # Get the item at `key`.
281 fun [](key
: K
): E
is abstract
283 # Get the item at `key` or null if `key` is not in the map.
285 # var x = new HashMap[String, Int]
287 # assert x.get_or_null("four") == 4
288 # assert x.get_or_null("five") == null
290 # Note: use `has_key` and `[]` if you need the distinction bewteen a key associated with null, and no key.
291 fun get_or_null
(key
: K
): nullable E
293 if has_key
(key
) then return self[key
]
297 # Get the item at `key` or return `default` if not in map
298 fun get_or_default
(key
: K
, default
: E
): E
300 if has_key
(key
) then return self[key
]
304 # Depreciated alias for `keys.has`
305 fun has_key
(key
: K
): Bool do return self.keys
.has
(key
)
307 # Get a new iterator on the map.
308 fun iterator
: MapIterator[K
, E
] is abstract
310 # Return the point of view of self on the values only.
311 # Note that `self` and `values` are views on the same data;
312 # therefore any modification of one is visible on the other.
313 fun values
: Collection[E
] is abstract
315 # Return the point of view of self on the keys only.
316 # Note that `self` and `keys` are views on the same data;
317 # therefore any modification of one is visible on the other.
318 fun keys
: Collection[K
] is abstract
320 # Is there no item in the collection?
321 fun is_empty
: Bool is abstract
323 # Number of items in the collection.
324 fun length
: Int is abstract
326 # Called by the underling implementation of `[]` to provide a default value when a `key` has no value
327 # By default the behavior is to abort.
329 # Note: the value is returned *as is*, implementations may want to store the value in the map before returning it
331 protected fun provide_default_value
(key
: K
): E
do abort
334 # Maps are associative collections: `key` -> `item`.
336 # The main operator over maps is [].
338 # var map: Map[String, Int] = new ArrayMap[String, Int]
340 # map["one"] = 1 # Associate 'one' to '1'
341 # map["two"] = 2 # Associate 'two' to '2'
342 # assert map["one"] == 1
343 # assert map["two"] == 2
345 # Instances of maps can be used with the for structure
347 # for key, value in map do
348 # assert (key == "one" and value == 1) or (key == "two" and value == 2)
351 # The keys and values in the map can also be manipulated directly with the `keys` and `values` methods.
353 # assert map.keys.has("one") == true
354 # assert map.keys.has("tree") == false
355 # assert map.values.has(1) == true
356 # assert map.values.has(3) == false
358 interface Map[K
: Object, E
]
360 # Set the`item` at `key`.
361 fun []=(key
: K
, item
: E
) is abstract
363 # Add each (key,value) of `map` into `self`.
364 # If a same key exists in `map` and `self`, then the value in self is discarded.
365 fun recover_with
(map
: Map[K
, E
])
375 fun clear
is abstract
377 redef fun values
: RemovableCollection[E
] is abstract
379 redef fun keys
: RemovableCollection[K
] is abstract
383 interface MapIterator[K
: Object, E
]
386 fun item
: E
is abstract
388 # The key of the current item.
390 fun key
: K
is abstract
392 # Jump to the next item.
396 # Is there a current item ?
397 fun is_ok
: Bool is abstract
399 # Set a new `item` at `key`.
400 #fun item=(item: E) is abstract
403 # Iterator on a 'keys' point of view of a map
404 class MapKeysIterator[K
: Object, V
]
406 # The original iterator
407 var iterator
: MapIterator[K
, V
]
409 redef fun is_ok
do return self.iterator
.is_ok
410 redef fun next
do self.iterator
.next
411 redef fun item
do return self.iterator
.key
414 # Iterator on a 'values' point of view of a map
415 class MapValuesIterator[K
: Object, V
]
417 # The original iterator
418 var iterator
: MapIterator[K
, V
]
420 redef fun is_ok
do return self.iterator
.is_ok
421 redef fun next
do self.iterator
.next
422 redef fun item
do return self.iterator
.item
425 # Sequences are indexed collections.
426 # The first item is 0. The last is `length-1`.
427 interface SequenceRead[E
]
429 # Get the first item.
430 # Is equivalent with `self[0]`.
433 assert not_empty
: not is_empty
437 # Return the index=th element of the sequence.
438 # The first element is 0 and the last if `length-1`
439 # If index is invalid, the program aborts
440 fun [](index
: Int): E
is abstract
443 # Is equivalent with `self[length-1]`.
446 assert not_empty
: not is_empty
447 return self[length-1
]
450 # Return the index of the first occurrence of `item`.
451 # Return -1 if `item` is not found
452 # Comparison is done with ==
453 fun index_of
(item
: E
): Int
457 if i
.item
== item
then return i
.index
463 redef fun iterator
: IndexedIterator[E
] is abstract
465 # Two sequences are equals if they have the same items in the same order.
468 if not o
isa SequenceRead[nullable Object] then return false
470 if o
.length
!= l
then return false
473 if self[i
] != o
[i
] then return false
479 # because of the law between `==` and `hash`, hash is redefined to be the sum of the hash of the elements
483 for e
in self do res
+= res
.hash
488 # Sequence are indexed collection.
489 # The first item is 0. The last is `length-1`.
490 interface Sequence[E
]
491 super SequenceRead[E
]
492 super SimpleCollection[E
]
494 # Set the first item.
495 # Is equivalent with `self[0] = item`.
497 do self[0] = item
end
500 # Is equivalent with `self[length-1] = item`.
511 # A synonym of `push`
512 redef fun add
(e
) do push
(e
)
514 # Add an item after the last.
515 fun push
(e
: E
) is abstract
517 # Add each item of `coll` after the last.
518 fun append
(coll
: Collection[E
]) do for i
in coll
do push
(i
)
520 # Remove the last item.
521 fun pop
: E
is abstract
523 # Add an item before the last.
524 fun unshift
(e
: E
) is abstract
526 # Remove the first item.
527 # The second item become the first.
528 fun shift
: E
is abstract
530 # Set the `item` at `index`.
531 fun []=(index
: Int, item
: E
) is abstract
533 # Remove the item at `index` and shift all following elements
534 fun remove_at
(index
: Int) is abstract
537 # Iterators on indexed collections.
538 interface IndexedIterator[E
]
540 # The index of the current item.
541 fun index
: Int is abstract
544 # Associative arrays that internally uses couples to represent each (key, value) pairs.
545 interface CoupleMap[K
: Object, E
]
547 # Return the couple of the corresponding key
548 # Return null if the key is no associated element
549 protected fun couple_at
(key
: K
): nullable Couple[K
, E
] is abstract
553 var c
= couple_at
(key
)
555 return provide_default_value
(key
)
562 # Iterator on CoupleMap
564 # Actually is is a wrapper around an iterator of the internal array of the map.
565 class CoupleMapIterator[K
: Object, E
]
566 super MapIterator[K
, E
]
567 redef fun item
do return _iter
.item
.second
569 #redef fun item=(e) do _iter.item.second = e
571 redef fun key
do return _iter
.item
.first
573 redef fun is_ok
do return _iter
.is_ok
580 var _iter
: Iterator[Couple[K
,E
]]
582 init(i
: Iterator[Couple[K
,E
]]) do _iter
= i
585 # Some tools ###################################################################
587 # Two objects in a simple structure.
590 # The first element of the couple.
591 readable writable var _first
: F
593 # The second element of the couple.
594 readable writable var _second
: S
596 # Create a new instance with a first and a second object.