Eiffeldoc: ARRAY

+

Point of view

All features

class ARRAY [E_]

Summary

General purpose resizable ARRAYs as they are define in the Eiffel language definition. The lower bound can be any arbitrary value, even a negative one.

This implementation uses only one chunk of memory, the storage area which is a NATIVE_ARRAY. One must keep in mind that this internal storage area is always kept left align. Thus, you can expect good performances while using an ARRAY to modelize a stack behavior with add_last / last / remove_last. Conversely add_first and remove_first are likely to slow down your program if they are too often used. If the fact that lower is always stuck to 0 is not a problem for you, also consider FAST_ARRAY to get better performances.

Direct parents: Inherit list: ARRAYED_COLLECTION, COLLECTION; Insert list: NATIVE_ARRAY_COLLECTOR

Class invariant

valid_bounds: lower <= upper + 1
capacity >= upper - lower + 1
capacity > 0 implies storage.is_not_null

Overview

Creation features

default_create

Default creation method.
make (min_index: INTEGER_32, max_index: INTEGER_32)

Prepare the array to hold values for indexes in range [min_index .. max_index].
with_capacity (needed_capacity: INTEGER_32, low: INTEGER_32)

Create an empty array with capacity initialized at least to needed_capacity and lower set to low.
from_collection (model: TRAVERSABLE[E_])

Initialize the current object with the contents of model.

Features

{}

default_create

Default creation method.

lower: INTEGER_32

Lower index bound.

Creation and Modification:

make (min_index: INTEGER_32, max_index: INTEGER_32)

Prepare the array to hold values for indexes in range [min_index .. max_index].
with_capacity (needed_capacity: INTEGER_32, low: INTEGER_32)

Create an empty array with capacity initialized at least to needed_capacity and lower set to low.

{}

ensure_capacity_and_bounds (needed_capacity: INTEGER_32, low: INTEGER_32, up: INTEGER_32)

Modification:

resize (min_index: INTEGER_32, max_index: INTEGER_32)

Resize to bounds min_index and max_index.
reindex (new_lower: INTEGER_32)

Change indexing to take in account the expected new_lower index.

Implementation of deferred:

count: INTEGER_32

Number of available items in the hoard.
is_empty: BOOLEAN

Is the hoard empty ?

See also count.
subarray (min: INTEGER_32, max: INTEGER_32): ARRAY [E_]

New collection consisting of items at indexes in [min .. max].
item (i: INTEGER_32): E_

Item at the corresponding index i.
put (element: E_, i: INTEGER_32)

Make element the item at index i.
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: ARRAY [E_])

Reinitialize by copying all the items of other.
set_all_with (v: E_)

Set all items with value v.
remove_first

Remove the first element of the collection.
remove_head (n: INTEGER_32)

Remove the n elements of the collection.
remove (index: INTEGER_32)

Remove the item at position index.
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).
add_first (element: E_)

Add a new item in first position : count is increased by one and all other items are shifted right.
add_last (element: E_)

Add a new item at the end : count is increased by one.
from_collection (model: TRAVERSABLE[E_])

Initialize the current object with the contents of model.
all_default: BOOLEAN

Do all items have their type's default value?
occurrences (element: E_): INTEGER_32

Number of occurrences of element using is_equal for comparison.
fast_occurrences (element: E_): INTEGER_32

Number of occurrences of element using basic = for comparison.
first_index_of (element: E_): INTEGER_32

Give the index of the first occurrence of element using is_equal for comparison.
index_of (element: E_, 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: E_, 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_first_index_of (element: E_): INTEGER_32

Give the index of the first occurrence of element using basic = for comparison.
fast_index_of (element: E_, 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: E_, start_index: INTEGER_32): INTEGER_32

Using basic = comparison, gives the index of the first occurrence of element at or before start_index.
fast_is_equal (other: ARRAY [E_]): BOOLEAN

Do both collections have the same lower, upper, and items?
is_equal (other: ARRAY [E_]): BOOLEAN

Do both collections have the same lower, upper, and items?
slice (min: INTEGER_32, max: INTEGER_32): ARRAY [E_]

New collection consisting of items at indexes in [min..max].
new_iterator: ITERATOR[E_]

Garbage collector tuning (very low-level):

{}

mark_native_arrays

For performance reasons, the unused area of storage is always left as it is when some elements are removed.

Implement manifest generic creation (very low-level):

{}

manifest_make (needed_capacity: INTEGER_32, initial_lower: INTEGER_32)

Manifest creation of an ARRAY[E_] with lower set to initial_lower.
manifest_put (index: INTEGER_32, element: E_)

Accessing:

infix "@" (i: INTEGER_32): E_

The infix notation which is actually just a synonym for item.

Writing:

swap (i1: INTEGER_32, i2: INTEGER_32)

Swap item at index i1 with item at index i2.
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:

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.

Removing:

remove_last

Remove the last item.
remove_tail (n: INTEGER_32)

Remove the last n item(s).

Looking and Searching:

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:

is_equal_map (other: ARRAY [E_]): BOOLEAN

Do both collections have the same lower, upper, and items?
same_items (other: COLLECTION[E_]): BOOLEAN

Do both collections have the same items?

Other features:

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 ..
reverse

Reverse the order of the elements.

Implement manifest generic creation:

{}

manifest_semicolon_check: BOOLEAN

enumerate: ENUMERATE[E_]

Other features:

get_new_iterator: ITERATOR[E_]

Agent-based features:

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:

out_in_tagged_out_memory

Append terse printable representation of current object in tagged_out_memory.

generation: INTEGER_32

{}

next_generation

Agent-based features:

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:

upper: INTEGER_32

Maximum index.
valid_index (i: INTEGER_32): BOOLEAN

True when i is valid (i.e., inside actual bounds).

Accessing:

first: E_

The very first item.
last: E_

The last item.

{ARRAYED_COLLECTION, ARRAYED_COLLECTION_HANDLER}

storage: NATIVE_ARRAY[E_]

Internal access to storage location.
from_external (a_storage: POINTER, a_capacity: INTEGER_32)

capacity: INTEGER_32

Internal storage capacity in number of item.

Interfacing with C:

to_external: POINTER

Gives C access into the internal storage of the ARRAY.

{ARRAYED_COLLECTION}

set_upper (new_upper: INTEGER_32)

{}

mark_item (native_array: NATIVE_ARRAY[E_], index: INTEGER_32)

To be used _only_ inside the definition of mark_native_arrays.

default_create

effective procedure

{}

Default creation method.

lower: INTEGER_32

writable attribute

Lower index bound.

make (min_index: INTEGER_32, max_index: INTEGER_32)

effective procedure

Prepare the array to hold values for indexes in range [min_index .. max_index].

with_capacity (needed_capacity: INTEGER_32, low: INTEGER_32)

effective procedure

Create an empty array with capacity initialized at least to needed_capacity and lower set to low.

ensure_capacity_and_bounds (needed_capacity: INTEGER_32, low: INTEGER_32, up: INTEGER_32)

effective procedure

{}

resize (min_index: INTEGER_32, max_index: INTEGER_32)

effective procedure

Resize to bounds min_index and max_index.

reindex (new_lower: INTEGER_32)

effective procedure

Change indexing to take in account the expected new_lower index.

count: INTEGER_32

effective function

Number of available items in the hoard.

is_empty: BOOLEAN

effective function

Is the hoard empty ?

See also count.

subarray (min: INTEGER_32, max: INTEGER_32): ARRAY [E_]

effective function

New collection consisting of items at indexes in [min .. max].

item (i: INTEGER_32): E_

effective function

Item at the corresponding index i.

put (element: E_, i: INTEGER_32)

effective procedure

Make element the item at index i.

force (element: E_, index: INTEGER_32)

effective procedure

Make element the item at index, enlarging the collection if necessary (new bounds except index are initialized with default values).

copy (other: ARRAY [E_])

effective procedure

Reinitialize by copying all the items of other.

set_all_with (v: E_)

effective procedure

Set all items with value v.

remove_first

effective procedure

Remove the first element of the collection.

remove_head (n: INTEGER_32)

effective procedure

Remove the n elements of the collection.

remove (index: INTEGER_32)

effective procedure

Remove the item at position index.

clear_count

effective procedure

Discard all items (is_empty is True after that call).

clear_count_and_capacity

effective procedure

Discard all items (is_empty is True after that call).

add_first (element: E_)

effective procedure

Add a new item in first position : count is increased by one and all other items are shifted right.

add_last (element: E_)

effective procedure

Add a new item at the end : count is increased by one.

from_collection (model: TRAVERSABLE[E_])

effective procedure

Initialize the current object with the contents of model.

all_default: BOOLEAN

effective function

Do all items have their type's default value?

occurrences (element: E_): INTEGER_32

effective function

Number of occurrences of element using is_equal for comparison.

fast_occurrences (element: E_): INTEGER_32

effective function

Number of occurrences of element using basic = for comparison.

first_index_of (element: E_): INTEGER_32

effective function

Give the index of the first occurrence of element using is_equal for comparison.

index_of (element: E_, start_index: INTEGER_32): INTEGER_32

effective function

Using is_equal for comparison, gives the index of the first occurrence of element at or after start_index.

reverse_index_of (element: E_, start_index: INTEGER_32): INTEGER_32

effective function

Using is_equal for comparison, gives the index of the first occurrence of element at or before start_index.

fast_first_index_of (element: E_): INTEGER_32

effective function

Give the index of the first occurrence of element using basic = for comparison.

fast_index_of (element: E_, start_index: INTEGER_32): INTEGER_32

effective function

Using basic = for comparison, gives the index of the first occurrence of element at or after start_index.

fast_reverse_index_of (element: E_, start_index: INTEGER_32): INTEGER_32

effective function

Using basic = comparison, gives the index of the first occurrence of element at or before start_index.

fast_is_equal (other: ARRAY [E_]): BOOLEAN

effective function

Do both collections have the same lower, upper, and items?

is_equal (other: ARRAY [E_]): BOOLEAN

effective function

Do both collections have the same lower, upper, and items?

slice (min: INTEGER_32, max: INTEGER_32): ARRAY [E_]

effective function

New collection consisting of items at indexes in [min..max].

new_iterator: ITERATOR[E_]

effective function

mark_native_arrays

effective procedure

{}

For performance reasons, the unused area of storage is always left as it is when some elements are removed.

manifest_make (needed_capacity: INTEGER_32, initial_lower: INTEGER_32)

effective procedure

{}

Manifest creation of an ARRAY[E_] with lower set to initial_lower.

manifest_put (index: INTEGER_32, element: E_)

effective procedure

{}

infix "@" (i: INTEGER_32): E_

frozen

effective function

The infix notation which is actually just a synonym for item.

swap (i1: INTEGER_32, i2: INTEGER_32)

effective procedure

Swap item at index i1 with item at index i2.

set_slice_with (v: ANY, lower_index: INTEGER_32, upper_index: INTEGER_32)

effective procedure

Set all items in range [lower_index .. upper_index] with v.

clear_all

effective procedure

Set every item to its default value.

add (element: ANY, index: INTEGER_32)

deferred procedure

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_])

effective procedure

Append other to Current.

append_traversable (other: TRAVERSABLE[E_])

effective procedure

Append other to Current.

remove_last

deferred procedure

Remove the last item.

remove_tail (n: INTEGER_32)

deferred procedure

Remove the last n item(s).

has (x: ANY): BOOLEAN

effective function

Look for x using is_equal for comparison.

fast_has (x: ANY): BOOLEAN

effective function

Look for x using basic = for comparison.

last_index_of (element: ANY): INTEGER_32

effective function

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

effective function

Using basic = for comparison, gives the index of the last occurrence of element at or before upper.

is_equal_map (other: ARRAY [E_]): BOOLEAN

effective function

Do both collections have the same lower, upper, and items?

same_items (other: COLLECTION[E_]): BOOLEAN

effective function

Do both collections have the same items?

replace_all (old_value: ANY, new_value: ANY)

deferred procedure

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)

deferred procedure

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)

effective procedure

Move range lower_index ..

reverse

deferred procedure

Reverse the order of the elements.

manifest_semicolon_check: BOOLEAN

is False

constant attribute

{}

enumerate: ENUMERATE[E_]

effective function

get_new_iterator: ITERATOR[E_]

frozen

effective function

for_each (action: PROCEDURE[TUPLE[TUPLE 1[E_]]])

effective procedure

Apply action to every item of Current.

for_all (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN

effective function

Do all items satisfy test?

exists (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN

effective function

Does at least one item satisfy test?

aggregate (action: FUNCTION[TUPLE[TUPLE 2[E_, E_], E_]], initial: E_): E_

effective function

Aggregate all the elements starting from the initial value.

out_in_tagged_out_memory

effective procedure

Append terse printable representation of current object in tagged_out_memory.

generation: INTEGER_32

writable attribute

next_generation

effective procedure

{}

do_all (action: ROUTINE[TUPLE[TUPLE 1[E_]]])

frozen

effective procedure

Apply action to every item of Current.

_inline_agent1 (a: ROUTINE[TUPLE[TUPLE 1[E_]]], e: E_)

frozen

effective procedure

{}

upper: INTEGER_32

deferred function

Maximum index.

valid_index (i: INTEGER_32): BOOLEAN

effective function

True when i is valid (i.e., inside actual bounds).

first: E_

deferred function

The very first item.

last: E_

deferred function

The last item.

storage: NATIVE_ARRAY[E_]

writable attribute

{ARRAYED_COLLECTION, ARRAYED_COLLECTION_HANDLER}

Internal access to storage location.

from_external (a_storage: POINTER, a_capacity: INTEGER_32)

effective procedure

{ARRAYED_COLLECTION, ARRAYED_COLLECTION_HANDLER}

capacity: INTEGER_32

writable attribute

Internal storage capacity in number of item.

to_external: POINTER

effective function

Gives C access into the internal storage of the ARRAY.

set_upper (new_upper: INTEGER_32)

effective procedure

{ARRAYED_COLLECTION}

mark_item (native_array: NATIVE_ARRAY[E_], index: INTEGER_32)

{}

To be used _only_ inside the definition of mark_native_arrays.