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 abtract collection classes.
14 package abstract_collection
18 # The root of the collection hierarchy.
20 # Instances of this class offers an iterator method.
22 # Colections instances can use the "for" structure:
23 # var x: Collection[U]
29 # that is equivalent with
30 # var x: Collection[U]
34 # var u = i.item # u is a U
39 # This abstract class implements its others methods with an iterator.
40 # Subclasses may redefine them with an efficient implementation.
41 interface Collection[E
]
42 # Get a new iterator on the collection.
43 fun iterator
: Iterator[E
] is abstract
45 # Iterate over each element of the collection
56 # Is there no item in the collection ?
57 fun is_empty
: Bool is abstract
59 # Number of items in the collection.
60 fun length
: Int is abstract
62 # Is `item' in the collection ?
63 # Comparaisons are done with ==
64 fun has
(item
: E
): Bool is abstract
66 # Is the collection contain only `item' ?
67 # Comparaisons are done with ==
68 # Return true if the collection is empty.
69 fun has_only
(item
: E
): Bool is abstract
71 # How many occurences of `item' are in the collection ?
72 # Comparaisons are done with ==
73 fun count
(item
: E
): Int is abstract
75 # Return one the item of the collection
76 fun first
: E
is abstract
79 # Naive implementation of collections method
80 # You only have to define iterator!
81 interface NaiveCollection[E
]
83 redef fun is_empty
do return length
== 0
88 for i
in self do nb
+= 1
94 for i
in self do if i
== item
then return true
98 redef fun has_only
(item
)
100 for i
in self do if i
!= item
then return false
104 redef fun count
(item
)
107 for i
in self do if i
== item
then nb
+= 1
118 # Instances of the Iterator class generates a series of elements, one at a time.
119 # They are mainly used with collections.
120 interface Iterator[E
]
123 fun item
: E
is abstract
125 # Jump to the next item.
129 # Is there a current item ?
130 fun is_ok
: Bool is abstract
133 # A collection that contains only one item.
137 redef fun first
do return _item
139 redef fun is_empty
do return false
141 redef fun length
do return 1
143 redef fun has
(an_item
) do return _item
== an_item
145 redef fun has_only
(an_item
) do return _item
== an_item
147 redef fun count
(an_item
)
149 if _item
== an_item
then
156 redef fun iterator
do return new ContainerIterator[E
](self)
158 # Create a new instance with a given initial value.
159 init(e
: E
) do _item
= e
162 readable writable var _item
: E
165 # This iterator is quite stupid since it is used for only one item.
166 class ContainerIterator[E
]
168 redef fun item
do return _container
.item
170 redef fun next
do _is_ok
= false
172 init(c
: Container[E
]) do _container
= c
174 redef readable var _is_ok
: Bool = true
176 var _container
: Container[E
]
179 # Items can be removed from this collection
180 interface RemovableCollection[E
]
183 fun clear
is abstract
185 # Remove an occucence of `item'
186 fun remove
(item
: E
) is abstract
188 # Remove all occurences of `item'
189 fun remove_all
(item
: E
) do while has
(item
) do remove
(item
)
192 # Items can be added to these collections.
193 interface SimpleCollection[E
]
194 super RemovableCollection[E
]
195 # Add an item in a collection.
196 # Ensure col.has(item)
197 fun add
(item
: E
) is abstract
199 # Add each item of `coll`.
200 fun add_all
(coll
: Collection[E
]) do for i
in coll
do add
(i
)
205 # Set contains contains only one element with the same value (according to =).
211 # s.has(b) # --> true
212 interface Set[E
: Object]
213 super SimpleCollection[E
]
215 redef fun has_only
(item
)
228 redef fun count
(item
)
237 # Synonym of remove since there is only one item
238 redef fun remove_all
(item
) do remove
(item
)
241 interface MapRead[K
: Object, E
]
242 # Get the item at `key'.
243 fun [](key
: K
): E
is abstract
245 # Depreciated alias for `keys.has'
246 fun has_key
(key
: K
): Bool do return self.keys
.has
(key
)
248 # Get a new iterator on the map.
249 fun iterator
: MapIterator[K
, E
] is abstract
251 # Iterate over each element of the collection
262 # Return the point of view of self on the values only
263 fun values
: Collection[E
] is abstract
265 # Return the point of view of self on the keys only
266 fun keys
: Collection[E
] is abstract
268 # Is there no item in the collection ?
269 fun is_empty
: Bool is abstract
271 # Number of items in the collection.
272 fun length
: Int is abstract
274 # Depreciated alias for `values.has'
275 fun has
(item
: E
): Bool do return self.values
.has
(item
)
277 # Depreciated alias for `values.has_only'
278 fun has_only
(item
: E
): Bool do return self.values
.has_only
(item
)
280 # Depreciated alias for `values.count'
281 fun count
(item
: E
): Int do return self.values
.count
(item
)
283 # Depreciated alias for `values.first'
284 fun first
: E
do return self.values
.first
287 # Maps are associative collections: `key' -> `item'.
289 # The main operator over maps is [].
293 # map[u1] = v1 # Associate 'v1' to 'u1'
294 # map[u2] = v2 # Associate 'v2' to 'u2'
297 # map.has_key(u1) # -> true
298 # map.has_key(u3) # -> false
299 interface Map[K
: Object, E
]
301 # Set the`item' at `key'.
302 fun []=(key
: K
, item
: E
) is abstract
304 # Depreciated alias for `keys.remove`
305 fun remove_at
(key
: K
) do keys
.remove
(key
)
307 # Add each (key,value) of `map' into `self'.
308 # If a same key exists in `map' and `self', then the value in self is discarded.
309 fun recover_with
(map
: Map[K
, E
])
319 fun clear
is abstract
321 # Depreciated alias for `values.remove`
322 fun remove
(item
: E
) do values
.remove
(item
)
324 # Depreciated alias for `values.remove_all`
325 fun remove_all
(item
: E
) do values
.remove_all
(item
)
327 redef fun values
: RemovableCollection[E
] is abstract
329 redef fun keys
: RemovableCollection[E
] is abstract
333 interface MapIterator[K
: Object, E
]
336 fun item
: E
is abstract
338 # The key of the current item.
340 fun key
: K
is abstract
342 # Jump to the next item.
346 # Is there a current item ?
347 fun is_ok
: Bool is abstract
349 # Set a new `item' at `key'.
350 #fun item=(item: E) is abstract
353 # Iterator on a 'keys' point of view of a map
354 class MapKeysIterator[K
: Object, V
]
356 # The original iterator
357 var iterator
: MapIterator[K
, V
]
359 redef fun is_ok
do return self.iterator
.is_ok
360 redef fun next
do self.iterator
.next
361 redef fun item
do return self.iterator
.key
364 # Iterator on a 'values' point of view of a map
365 class MapValuesIterator[K
: Object, V
]
367 # The original iterator
368 var iterator
: MapIterator[K
, V
]
370 redef fun is_ok
do return self.iterator
.is_ok
371 redef fun next
do self.iterator
.next
372 redef fun item
do return self.iterator
.item
375 # Indexed collection are ordoned collections.
376 # The first item is 0. The last is `length'-1.
377 interface SequenceRead[E
]
379 # Get the first item.
380 # Is equivalent with `self'[0].
383 assert not_empty
: not is_empty
387 fun [](index
: Int): E
is abstract
390 # Is equivalent with `self'[`length'-1].
393 assert not_empty
: not is_empty
394 return self[length-1
]
397 # Return the index of the first occurence of `item'.
398 # Return -1 if `item' is not found
399 fun index_of
(item
: E
): Int
403 if i
.item
== item
then return i
.index
409 redef fun iterator
: IndexedIterator[E
] is abstract
412 # Indexed collection are ordoned collections.
413 # The first item is 0. The last is `length'-1.
414 interface Sequence[E
]
415 super SequenceRead[E
]
416 super SimpleCollection[E
]
417 # Set the first item.
418 # Is equivalent with `self'[0] = `item'.
420 do self[0] = item
end
423 # Is equivalent with `self'[length-1] = `item'.
434 # A synonym of `push'
435 redef fun add
(e
) do push
(e
)
437 # Add an item after the last.
438 fun push
(e
: E
) is abstract
440 # Add each item of `coll` after the last.
441 fun append
(coll
: Collection[E
]) do for i
in coll
do push
(i
)
443 # Remove the last item.
444 fun pop
: E
is abstract
446 # Add an item before the last.
447 fun unshift
(e
: E
) is abstract
449 # Remove the first item.
450 # The second item become the first.
451 fun shift
: E
is abstract
453 # Set the`item' at `index'.
454 fun []=(index
: Int, item
: E
) is abstract
456 # Remove the item at `index' and shift all following elements
457 fun remove_at
(index
: Int) is abstract
460 # Iterators on indexed collections.
461 interface IndexedIterator[E
]
463 # The index of the current item.
464 fun index
: Int is abstract
467 # Associatives arrays that internally uses couples to represent each (key, value) pairs.
468 interface CoupleMap[K
: Object, E
]
470 # Return the couple of the corresponding key
471 # Return null if the key is no associated element
472 protected fun couple_at
(key
: K
): nullable Couple[K
, E
] is abstract
476 var c
= couple_at
(key
)
485 # Iterator on CoupleMap
487 # Actually is is a wrapper around an iterator of the internal array of the map.
488 class CoupleMapIterator[K
: Object, E
]
489 super MapIterator[K
, E
]
490 redef fun item
do return _iter
.item
.second
492 #redef fun item=(e) do _iter.item.second = e
494 redef fun key
do return _iter
.item
.first
496 redef fun is_ok
do return _iter
.is_ok
503 var _iter
: Iterator[Couple[K
,E
]]
505 init(i
: Iterator[Couple[K
,E
]]) do _iter
= i
508 # Some tools ###################################################################
510 # Two objects in a simple structure.
513 # The first element of the couple.
514 readable writable var _first
: F
516 # The second element of the couple.
517 readable writable var _second
: S
519 # Create a new instance with a first and a second object.