+
Point of view
All features
deferred class TRAVERSABLE [E_]
Summary
A TRAVERSABLE[E_] is a finite readable sequence of objects of type E_. For instance, COLLECTIONs and STRINGs are TRAVERSABLE.
A good performance should always be obtained by sequentially accessing a TRAVERSABLE with increasing indexes (from lower to upper), as demonstrated in the following code snippet :
 from
    i := a_traversable.lower
 until
    i > a_traversable.upper
 loop
    do_something_with(a_traversable.item(i))
    i := i + 1
 end
Other accessing methods (including random access and sequential access from upper to lower) may or may not lead to acceptable performance, depending on the particular implementation of TRAVERSABLE.
Direct parents
Inherit list: INDEXABLE, ITERABLE
Known children
Inherit list: ABSTRACT_STRING, BIT_STRING, CLARG_WITH_ARGS, COLLECTION, DICTIONARY_KEY_TRAVERSER, DIRECTORY, INTEGER_RANGE, JSON_ARRAY, MAP, NCURSES_LIST, SET, UNICODE_STRING
Insert list: EIFFEL_LIST_NODE, EIFFEL_LIST_NODE_IMPL
Overview
Features
{ANY}
Other features:
{ANY}
Agent-based features:
{ANY}
Printing:
{ANY}
{ANY}
{}
Counting:
{ANY}
Agent-based features:
{ANY}
{}
Indexing:
{ANY}
Accessing:
{ANY}
enumerate: ENUMERATE[E_]
effective function
{ANY}
new_iterator: ITERATOR[E_]
deferred function
{ANY}
ensure
get_new_iterator: ITERATOR[E_]
frozen
effective function
{ANY}
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}
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}
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}
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}
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}
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}
next_generation
effective procedure
{}
ensure
count: INTEGER_32
deferred function
{ANY}
Number of available items in the hoard.
See also is_empty
ensure
  • Result >= 0
is_empty: BOOLEAN
deferred function
{ANY}
Is the hoard empty ?
See also count.
ensure
  • definition: Result = count = 0
do_all (action: ROUTINE[TUPLE[TUPLE 1[E_]]])
frozen
effective procedure
{ANY}
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
{}
lower: INTEGER_32
deferred function
{ANY}
Minimum index.
See also upper, valid_index, item.
upper: INTEGER_32
deferred function
{ANY}
Maximum index.
See also lower, valid_index, item.
valid_index (i: INTEGER_32): BOOLEAN
effective function
{ANY}
True when i is valid (i.e., inside actual bounds).
See also lower, upper, item.
ensure
item (i: INTEGER_32): E_
deferred function
{ANY}
Item at the corresponding index i.
See also lower, upper, valid_index.
require
first: E_
deferred function
{ANY}
The very first item.
See also last, item.
require ensure
last: E_
deferred function
{ANY}
The last item.
See also first, item.
require ensure