GNU
|
Liberty Eiffel
|
Automated Tests
|
Wiki
|
Savannah project
|
Debian packages
|
Documentation
>
libraries
>
LINKED_COLLECTION
+
Point of view
All features
ANY
All features
deferred class LINKED_COLLECTION [E_]
Summary
top
Common root of
LINKED_LIST
and
TWO_WAY_LINKED_LIST
.
Direct parents
Insert list:
COLLECTION
Known children
Insert list:
LINKED_LIST
,
TWO_WAY_LINKED_LIST
Class invariant
top
valid_bounds:
lower <= upper + 1
Overview
top
Features
{
ANY
}
lower
:
INTEGER_32
Lower index bound is frozen.
upper
:
INTEGER_32
Memorized upper index bound.
make
Make an empty list
remove_head
(n:
INTEGER_32
)
Remove the
n
elements of the collection.
remove_tail
(n:
INTEGER_32
)
Remove the last
n
item(s).
first_index_of
(element:
ANY
):
INTEGER_32
Give the index of the first occurrence of
element
using
is_equal
for comparison.
fast_first_index_of
(element:
ANY
):
INTEGER_32
Give the index of the first occurrence of
element
using basic
=
for comparison.
Implement manifest generic creation:
{}
manifest_make
(needed_capacity:
INTEGER_32
)
Manifest creation of a list of items of type E_.
manifest_put
(index:
INTEGER_32
, element:
ANY
)
Accessing:
{
ANY
}
infix "@"
(i:
INTEGER_32
): E_
The infix notation which is actually just a synonym for
item
.
Writing:
{
ANY
}
put
(element:
ANY
, i:
INTEGER_32
) assign
item
Make
element
the item at index
i
.
swap
(i1:
INTEGER_32
, i2:
INTEGER_32
)
Swap item at index
i1
with item at index
i2
.
set_all_with
(v:
ANY
)
Set all items with value
v
.
set_slice_with
(v:
ANY
, lower_index:
INTEGER_32
, upper_index:
INTEGER_32
)
Set all items in range [
lower_index
..
upper_index
] with
v
.
clear_all
Set every item to its default value.
Adding:
{
ANY
}
add_first
(element:
ANY
)
Add a new item in first position :
count
is increased by one and all other items are shifted right.
add_last
(element:
ANY
)
Add a new item at the end :
count
is increased by one.
add
(element:
ANY
, index:
INTEGER_32
)
Add a new
element
at rank
index
:
count
is increased by one and range [
index
..
upper
] is shifted right by one position.
append_collection
(other: COLLECTION[E_])
Append
other
to Current.
append_traversable
(other: TRAVERSABLE[E_])
Append
other
to Current.
Modification:
{
ANY
}
force
(element: E_, index:
INTEGER_32
)
Make
element
the item at
index
, enlarging the collection if necessary (new bounds except
index
are initialized with default values).
copy
(other: LINKED_COLLECTION [E_])
Reinitialize by copying all the items of
other
.
from_collection
(model: TRAVERSABLE[
ANY
])
Initialize the current object with the contents of
model
.
Removing:
{
ANY
}
remove_first
Remove the
first
element of the collection.
remove
(index:
INTEGER_32
)
Remove the item at position
index
.
remove_last
Remove the
last
item.
clear_count
Discard all items (
is_empty
is True after that call).
clear_count_and_capacity
Discard all items (
is_empty
is True after that call).
Looking and Searching:
{
ANY
}
has
(x:
ANY
):
BOOLEAN
Look for
x
using
is_equal
for comparison.
fast_has
(x:
ANY
):
BOOLEAN
Look for
x
using basic
=
for comparison.
last_index_of
(element:
ANY
):
INTEGER_32
Using
is_equal
for comparison, gives the index of the last occurrence of
element
at or before
upper
.
fast_last_index_of
(element:
ANY
):
INTEGER_32
Using basic
=
for comparison, gives the index of the last occurrence of
element
at or before
upper
.
Looking and comparison:
{
ANY
}
fast_is_equal
(other: LINKED_COLLECTION [E_]):
BOOLEAN
Do both collections have the same
lower
,
upper
, and items?
is_equal
(other: LINKED_COLLECTION [E_]):
BOOLEAN
Do both collections have the same
lower
,
upper
, and items?
is_equal_map
(other: LINKED_COLLECTION [E_]):
BOOLEAN
Do both collections have the same
lower
,
upper
, and items?
all_default
:
BOOLEAN
Do all items have their type's default value?
same_items
(other: COLLECTION[E_]):
BOOLEAN
Do both collections have the same items?
occurrences
(element:
ANY
):
INTEGER_32
Number of occurrences of
element
using
is_equal
for comparison.
fast_occurrences
(element:
ANY
):
INTEGER_32
Number of occurrences of
element
using basic
=
for comparison.
Other features:
{
ANY
}
replace_all
(old_value:
ANY
, new_value:
ANY
)
Replace all occurrences of the element
old_value
by
new_value
using
is_equal
for comparison.
fast_replace_all
(old_value:
ANY
, new_value:
ANY
)
Replace all occurrences of the element
old_value
by
new_value
using basic
=
for comparison.
move
(lower_index:
INTEGER_32
, upper_index:
INTEGER_32
, distance:
INTEGER_32
)
Move range
lower_index
..
slice
(min:
INTEGER_32
, max:
INTEGER_32
): LINKED_COLLECTION [E_]
New collection consisting of items at indexes in [
min
..
max
].
reverse
Reverse the order of the elements.
Implement manifest generic creation:
{}
manifest_semicolon_check
:
BOOLEAN
{
ANY
}
enumerate
: ENUMERATE[E_]
Other features:
{
ANY
}
new_iterator
: ITERATOR[E_]
get_new_iterator
: ITERATOR[E_]
Agent-based features:
{
ANY
}
for_each
(action:
PROCEDURE
[
TUPLE
[TUPLE 1[E_]]])
Apply
action
to every item of
Current
.
for_all
(test:
FUNCTION
[
TUPLE
[TUPLE 1[E_]]]):
BOOLEAN
Do all items satisfy
test
?
exists
(test:
FUNCTION
[
TUPLE
[TUPLE 1[E_]]]):
BOOLEAN
Does at least one item satisfy
test
?
aggregate
(action:
FUNCTION
[
TUPLE
[TUPLE 2[E_, E_], E_]], initial: E_): E_
Aggregate all the elements starting from the initial value.
Printing:
{
ANY
}
out_in_tagged_out_memory
Append terse printable representation of current object in
tagged_out_memory
.
{
ANY
}
generation
:
INTEGER_32
{}
next_generation
Counting:
{
ANY
}
count
:
INTEGER_32
Number of available items in the hoard.
is_empty
:
BOOLEAN
Is the hoard empty ?
See also
count
.
Agent-based features:
{
ANY
}
do_all
(action:
ROUTINE
[
TUPLE
[TUPLE 1[E_]]])
Apply
action
to every item of
Current
.
{}
_inline_agent1
(a:
ROUTINE
[
TUPLE
[TUPLE 1[E_]]], e: E_)
Indexing:
{
ANY
}
valid_index
(i:
INTEGER_32
):
BOOLEAN
True when
i
is valid (i.e., inside actual bounds).
Accessing:
{
ANY
}
item
(i:
INTEGER_32
): E_
Item at the corresponding index
i
.
first
: E_
The very
first
item.
last
: E_
The
last
item.
Looking and Searching:
{
ANY
}
index_of
(element:
ANY
, start_index:
INTEGER_32
):
INTEGER_32
Using
is_equal
for comparison, gives the index of the first occurrence of
element
at or after
start_index
.
reverse_index_of
(element:
ANY
, start_index:
INTEGER_32
):
INTEGER_32
Using
is_equal
for comparison, gives the index of the first occurrence of
element
at or before
start_index
.
fast_index_of
(element:
ANY
, start_index:
INTEGER_32
):
INTEGER_32
Using basic
=
for comparison, gives the index of the first occurrence of
element
at or after
start_index
.
fast_reverse_index_of
(element:
ANY
, start_index:
INTEGER_32
):
INTEGER_32
Using basic
=
comparison, gives the index of the first occurrence of
element
at or before
start_index
.
lower
:
INTEGER_32
is 1
constant attribute
{
ANY
}
top
Lower index bound is frozen.
upper
:
INTEGER_32
writable attribute
{
ANY
}
top
Memorized upper index bound.
make
deferred procedure
{
ANY
}
top
Make an empty list
remove_head
(n:
INTEGER_32
)
effective procedure
{
ANY
}
top
Remove the
n
elements of the collection.
See also
remove_tail
,
remove
,
remove_first
.
require
n > 0 and n <= count
ensure
count = old count - n
lower = old lower + n xor upper = old upper - n
remove_tail
(n:
INTEGER_32
)
effective procedure
{
ANY
}
top
Remove the last
n
item(s).
See also
remove_head
,
remove
,
remove_last
.
require
n > 0 and n <= count
ensure
count = old count - n
upper = old upper - n
first_index_of
(element:
ANY
):
INTEGER_32
effective function
{
ANY
}
top
Give the index of the first occurrence of
element
using
is_equal
for comparison.
Answer
upper + 1
when
element
is not inside.
See also
fast_first_index_of
,
index_of
,
last_index_of
,
reverse_index_of
.
ensure
definition:
Result = index_of(element, lower)
fast_first_index_of
(element:
ANY
):
INTEGER_32
effective function
{
ANY
}
top
Give the index of the first occurrence of
element
using basic
=
for comparison.
Answer
upper + 1
when
element
is not inside.
See also
first_index_of
,
last_index_of
,
fast_last_index_of
.
ensure
definition:
Result = fast_index_of(element, lower)
manifest_make
(needed_capacity:
INTEGER_32
)
effective procedure
{}
top
Manifest creation of a list of items of type E_.
manifest_put
(index:
INTEGER_32
, element:
ANY
)
effective procedure
{}
top
require
index >= 0
infix "@"
(i:
INTEGER_32
): E_
frozen
effective function
{
ANY
}
top
The infix notation which is actually just a synonym for
item
.
See also
item
.
require
valid_index
(i)
ensure
definition:
Result =
item
(i)
put
(element:
ANY
, i:
INTEGER_32
) assign
item
deferred procedure
{
ANY
}
top
Make
element
the item at index
i
.
See also
lower
,
upper
,
valid_index
,
item
,
swap
,
force
.
require
valid_index
(i)
ensure
item
(i) = element
count
= old
count
swap
(i1:
INTEGER_32
, i2:
INTEGER_32
)
effective procedure
{
ANY
}
top
Swap item at index
i1
with item at index
i2
.
See also
item
,
put
.
require
valid_index
(i1)
valid_index
(i2)
ensure
item
(i1) = old
item
(i2)
item
(i2) = old
item
(i1)
count
= old
count
set_all_with
(v:
ANY
)
deferred procedure
{
ANY
}
top
Set all items with value
v
.
See also
set_slice_with
.
ensure
count
= old
count
set_slice_with
(v:
ANY
, lower_index:
INTEGER_32
, upper_index:
INTEGER_32
)
effective procedure
{
ANY
}
top
Set all items in range [
lower_index
..
upper_index
] with
v
.
See also
set_all_with
.
require
lower_index <= upper_index
valid_index
(lower_index)
valid_index
(upper_index)
ensure
count
= old
count
clear_all
effective procedure
{
ANY
}
top
Set every item to its default value.
The
count
is not affected.
See also
clear
,
all_default
.
ensure
stable_upper:
upper
= old
upper
stable_lower:
lower
= old
lower
all_default
add_first
(element:
ANY
)
deferred procedure
{
ANY
}
top
Add a new item in first position :
count
is increased by one and all other items are shifted right.
See also
add_last
,
first
,
last
,
add
.
ensure
first
= element
count
= 1 + old
count
lower
= old
lower
upper
= 1 + old
upper
add_last
(element:
ANY
)
deferred procedure
{
ANY
}
top
Add a new item at the end :
count
is increased by one.
See also
add_first
,
last
,
first
,
add
.
ensure
last
= element
count
= 1 + old
count
lower
= old
lower
upper
= 1 + old
upper
add
(element:
ANY
, index:
INTEGER_32
)
deferred procedure
{
ANY
}
top
Add a new
element
at rank
index
:
count
is increased by one and range [
index
..
upper
] is shifted right by one position.
See also
add_first
,
add_last
,
append_collection
.
require
index.in_range(
lower
,
upper
+ 1)
ensure
item
(index) = element
count
= 1 + old
count
upper
= 1 + old
upper
append_collection
(other: COLLECTION[E_])
effective procedure
{
ANY
}
top
Append
other
to Current.
This feature is obsolete:
Use `append_traversable' instead.
append_traversable
(other: TRAVERSABLE[E_])
effective procedure
{
ANY
}
top
Append
other
to Current.
See also
add_last
,
add_first
,
add
.
require
other /= Void
ensure
count
= other.count + old
count
force
(element: E_, index:
INTEGER_32
)
deferred procedure
{
ANY
}
top
Make
element
the item at
index
, enlarging the collection if necessary (new bounds except
index
are initialized with default values).
See also
put
,
item
,
swap
.
require
index >=
lower
ensure
upper
= index.max(old
upper
)
item
(index) = element
copy
(other: LINKED_COLLECTION [E_])
deferred procedure
{
ANY
}
top
Reinitialize by copying all the items of
other
.
require
not immutable
same_dynamic_type(other)
not immutable
same_dynamic_type(other)
not immutable
same_dynamic_type(other)
ensure
is_equal(other)
from_collection
(model: TRAVERSABLE[
ANY
])
deferred procedure
{
ANY
}
top
Initialize the current object with the contents of
model
.
require
model /= Void
useful_work:
model /= Current
ensure
count
= model.count
remove_first
deferred procedure
{
ANY
}
top
Remove the
first
element of the collection.
See also
remove_last
,
remove
,
remove_head
.
require
not
is_empty
ensure
count
= old
count
- 1
lower
= old
lower
+ 1 xor
upper
= old
upper
- 1
remove
(index:
INTEGER_32
)
deferred procedure
{
ANY
}
top
Remove the item at position
index
.
Followings items are shifted left by one position.
See also
remove_first
,
remove_head
,
remove_tail
,
remove_last
.
require
valid_index
(index)
ensure
count
= old
count
- 1
upper
= old
upper
- 1
remove_last
deferred procedure
{
ANY
}
top
Remove the
last
item.
See also
remove_first
,
remove
,
remove_tail
.
require
not
is_empty
ensure
count
= old
count
- 1
upper
= old
upper
- 1
clear_count
deferred procedure
{
ANY
}
top
Discard all items (
is_empty
is True after that call).
If possible, the actual implementation supposed to keep its internal storage area in order to refill
Current
in an efficient way.
See also
clear_count_and_capacity
.
ensure
is_empty:
count
= 0
clear_count_and_capacity
deferred procedure
{
ANY
}
top
Discard all items (
is_empty
is True after that call).
If possible, the actual implementation supposed to release its internal storage area for this memory to be used by other objects.
See also
clear_count
.
ensure
is_empty:
count
= 0
has
(x:
ANY
):
BOOLEAN
effective function
{
ANY
}
top
Look for
x
using
is_equal
for comparison.
See also
fast_has
,
index_of
,
fast_index_of
.
ensure
definition:
Result = valid_index(first_index_of(x))
fast_has
(x:
ANY
):
BOOLEAN
effective function
{
ANY
}
top
Look for
x
using basic
=
for comparison.
See also
has
,
fast_index_of
,
index_of
.
ensure
definition:
Result = valid_index(fast_first_index_of(x))
last_index_of
(element:
ANY
):
INTEGER_32
effective function
{
ANY
}
top
Using
is_equal
for comparison, gives the index of the last occurrence of
element
at or before
upper
.
Search is done in reverse direction, which means from the
upper
down to the
lower
index . Answer
lower -1
when the search fail.
See also
fast_last_index_of
,
reverse_index_of
,
index_of
.
ensure
definition:
Result = reverse_index_of(element, upper)
fast_last_index_of
(element:
ANY
):
INTEGER_32
effective function
{
ANY
}
top
Using basic
=
for comparison, gives the index of the last occurrence of
element
at or before
upper
.
Search is done in reverse direction, which means from the
upper
down to the
lower
index . Answer
lower -1
when the search fail.
See also
fast_reverse_index_of
,
last_index_of
.
ensure
definition:
Result = fast_reverse_index_of(element, upper)
fast_is_equal
(other: LINKED_COLLECTION [E_]):
BOOLEAN
deferred function
{
ANY
}
top
Do both collections have the same
lower
,
upper
, and items?
The basic
=
is used for comparison of items.
See also
is_equal
,
same_items
.
ensure
Result implies
lower
= other.
lower
and
upper
= other.
upper
is_equal
(other: LINKED_COLLECTION [E_]):
BOOLEAN
deferred function
{
ANY
}
top
Do both collections have the same
lower
,
upper
, and items?
Feature
is_equal
is used for comparison of items.
See also
fast_is_equal
,
same_items
.
require
other /= Void
other /= Void
other /= Void
ensure
Result implies
lower
= other.
lower
and
upper
= other.
upper
commutative:
generating_type = other.generating_type implies Result = other.is_equal(Current)
is_equal_map
(other: LINKED_COLLECTION [E_]):
BOOLEAN
effective function
{
ANY
}
top
Do both collections have the same
lower
,
upper
, and items?
This feature is obsolete:
Use `is_equal' instead.
all_default
:
BOOLEAN
deferred function
{
ANY
}
top
Do all items have their type's default value?
Note: for non Void items, the test is performed with the
is_default
predicate.
See also
clear_all
.
same_items
(other: COLLECTION[E_]):
BOOLEAN
effective function
{
ANY
}
top
Do both collections have the same items?
The basic
=
is used for comparison of items and indices are not considered (for example this routine may yield True with
Current
indexed in range [1..2] and
other
indexed in range [2..3]).
See also
is_equal
,
fast_is_equal
.
require
other /= Void
ensure
Result implies
count
= other.
count
occurrences
(element:
ANY
):
INTEGER_32
deferred function
{
ANY
}
top
Number of occurrences of
element
using
is_equal
for comparison.
See also
fast_occurrences
,
index_of
.
ensure
Result >= 0
fast_occurrences
(element:
ANY
):
INTEGER_32
deferred function
{
ANY
}
top
Number of occurrences of
element
using basic
=
for comparison.
See also
occurrences
,
index_of
.
ensure
Result >= 0
replace_all
(old_value:
ANY
, new_value:
ANY
)
deferred procedure
{
ANY
}
top
Replace all occurrences of the element
old_value
by
new_value
using
is_equal
for comparison.
See also
fast_replace_all
,
move
.
ensure
count
= old
count
not (create {
SAFE_EQUAL
}).test(old_value, new_value) implies
occurrences
(old_value) = 0
fast_replace_all
(old_value:
ANY
, new_value:
ANY
)
deferred procedure
{
ANY
}
top
Replace all occurrences of the element
old_value
by
new_value
using basic
=
for comparison.
See also
replace_all
,
move
.
ensure
count
= old
count
old_value /= new_value implies
fast_occurrences
(old_value) = 0
move
(lower_index:
INTEGER_32
, upper_index:
INTEGER_32
, distance:
INTEGER_32
)
effective procedure
{
ANY
}
top
Move range
lower_index
..
upper_index
by
distance
positions. Negative distance moves towards lower indices. Free places get default values.
See also
slice
,
replace_all
.
require
lower_index <= upper_index
valid_index
(lower_index)
valid_index
(lower_index + distance)
valid_index
(upper_index)
valid_index
(upper_index + distance)
ensure
count
= old
count
slice
(min:
INTEGER_32
, max:
INTEGER_32
): LINKED_COLLECTION [E_]
deferred function
{
ANY
}
top
New collection consisting of items at indexes in [
min
..
max
].
Result has the same dynamic type as
Current
. The
lower
index of the
Result
is the same as
lower
.
See also
from_collection
,
move
,
replace_all
.
require
lower
<= min
max <=
upper
min <= max + 1
ensure
same_dynamic_type
(Result)
Result.
count
= max - min + 1
Result.
lower
=
lower
reverse
deferred procedure
{
ANY
}
top
Reverse the order of the elements.
ensure
count
= old
count
manifest_semicolon_check
:
BOOLEAN
is False
constant attribute
{}
top
enumerate
: ENUMERATE[E_]
effective function
{
ANY
}
top
new_iterator
: ITERATOR[E_]
deferred function
{
ANY
}
top
ensure
Result /= Void
Result.generation =
generation
get_new_iterator
: ITERATOR[E_]
frozen
effective function
{
ANY
}
top
This feature is obsolete:
Use `new_iterator' instead. This historical SmartEiffel feature is badly named.
for_each
(action:
PROCEDURE
[
TUPLE
[TUPLE 1[E_]]])
effective procedure
{
ANY
}
top
Apply
action
to every item of
Current
.
See also
for_all
,
exists
,
aggregate
.
require
action /= Void
for_all
(test:
FUNCTION
[
TUPLE
[TUPLE 1[E_]]]):
BOOLEAN
effective function
{
ANY
}
top
Do all items satisfy
test
?
See also
for_each
,
exists
,
aggregate
.
require
test /= Void
exists
(test:
FUNCTION
[
TUPLE
[TUPLE 1[E_]]]):
BOOLEAN
effective function
{
ANY
}
top
Does at least one item satisfy
test
?
See also
for_each
,
for_all
,
aggregate
.
require
test /= Void
aggregate
(action:
FUNCTION
[
TUPLE
[TUPLE 2[E_, E_], E_]], initial: E_): E_
effective function
{
ANY
}
top
Aggregate all the elements starting from the initial value.
See also
for_each
,
for_all
,
exists
.
require
action /= Void
out_in_tagged_out_memory
effective procedure
{
ANY
}
top
Append terse printable representation of current object in
tagged_out_memory
.
require
locked:
tagged_out_locked
ensure
still_locked:
tagged_out_locked
not_cleared:
tagged_out_memory.count >= old tagged_out_memory.count
append_only:
old tagged_out_memory.twin.is_equal(tagged_out_memory.substring(1, old tagged_out_memory.count))
generation
:
INTEGER_32
writable attribute
{
ANY
}
top
next_generation
effective procedure
{}
top
ensure
generation
> old
generation
count
:
INTEGER_32
deferred function
{
ANY
}
top
Number of available items in the hoard.
See also
is_empty
ensure
Result >= 0
is_empty
:
BOOLEAN
deferred function
{
ANY
}
top
Is the hoard empty ?
See also
count
.
ensure
definition:
Result =
count
= 0
do_all
(action:
ROUTINE
[
TUPLE
[TUPLE 1[E_]]])
frozen
effective procedure
{
ANY
}
top
Apply
action
to every item of
Current
.
This feature is obsolete:
Use `for_each` instead. This feature is not secure because it accepts a FUNCTION, the result of which is lost.
_inline_agent1
(a:
ROUTINE
[
TUPLE
[TUPLE 1[E_]]], e: E_)
frozen
effective procedure
{}
top
valid_index
(i:
INTEGER_32
):
BOOLEAN
effective function
{
ANY
}
top
True when
i
is valid (i.e., inside actual bounds).
See also
lower
,
upper
,
item
.
ensure
definition:
Result =
lower
<= i and i <=
upper
item
(i:
INTEGER_32
): E_
deferred function
{
ANY
}
top
Item at the corresponding index
i
.
See also
lower
,
upper
,
valid_index
.
require
valid_index
(i)
first
: E_
deferred function
{
ANY
}
top
The very
first
item.
See also
last
,
item
.
require
not
is_empty
ensure
definition:
Result =
item
(
lower
)
last
: E_
deferred function
{
ANY
}
top
The
last
item.
See also
first
,
item
.
require
not
is_empty
ensure
definition:
Result =
item
(
upper
)
index_of
(element:
ANY
, start_index:
INTEGER_32
):
INTEGER_32
deferred function
{
ANY
}
top
Using
is_equal
for comparison, gives the index of the first occurrence of
element
at or after
start_index
.
Return
upper + 1
if the search for
element
failed.
See also
fast_index_of
,
reverse_index_of
,
first_index_of
.
ensure
Result.in_range(start_index,
upper
+ 1)
valid_index
(Result) implies (create {
SAFE_EQUAL
}).test(element,
item
(Result))
reverse_index_of
(element:
ANY
, start_index:
INTEGER_32
):
INTEGER_32
deferred function
{
ANY
}
top
Using
is_equal
for comparison, gives the index of the first occurrence of
element
at or before
start_index
.
Search is done in reverse direction, which means from the
start_index
down to the
lower
index . Answer
lower -1
when the search fail.
See also
fast_reverse_index_of
,
last_index_of
,
index_of
.
require
valid_index
(start_index)
ensure
Result.in_range(
lower
- 1, start_index)
valid_index
(Result) implies
item
(Result).is_equal(element)
fast_index_of
(element:
ANY
, start_index:
INTEGER_32
):
INTEGER_32
deferred function
{
ANY
}
top
Using basic
=
for comparison, gives the index of the first occurrence of
element
at or after
start_index
.
Answer
upper + 1
when
element
when the search fail.
See also
index_of
,
fast_reverse_index_of
,
fast_first_index_of
.
ensure
Result.in_range(start_index,
upper
+ 1)
valid_index
(Result) implies element =
item
(Result)
fast_reverse_index_of
(element:
ANY
, start_index:
INTEGER_32
):
INTEGER_32
deferred function
{
ANY
}
top
Using basic
=
comparison, gives the index of the first occurrence of
element
at or before
start_index
.
Search is done in reverse direction, which means from the
start_index
down to the
lower
index . Answer
lower -1
when the search fail.
See also
reverse_index_of
,
fast_index_of
,
fast_last_index_of
.
require
valid_index
(start_index)
ensure
Result.in_range(
lower
- 1, start_index)
valid_index
(Result) implies
item
(Result) = element