Eiffeldoc: TWO_WAY_LINKED

Point of view

All features

class TWO_WAY_LINKED_LIST [E_]

Summary

top

Two way linked list with internal automatic memorization of the last access.

Direct parents: Inherit list: COLLECTION; Insert list: LINKED_COLLECTION

Class invariant

top

empty_status: first_link = Void implies last_link = Void and upper = 0 and mem_idx = 0 and mem_lnk = Void
not_empty_status: first_link /= Void implies last_link /= Void and upper > 0 and mem_idx > 0 and mem_lnk /= Void
valid_bounds: lower <= upper + 1

Overview

top

Creation features

{ANY}

make

Make an empty list
from_collection (model: TRAVERSABLE[E_])

Initialize the current object with the contents of model.
default_create

Default creation method.

Features

{}

default_create

Default creation method.

{TWO_WAY_LINKED_LIST, ITERATOR_ON_TWO_WAY_LINKED_LIST}

first_link: TWO_WAY_LINKED_LIST_NODE[E_]

Void when empty or gives access to the first element.

{TWO_WAY_LINKED_LIST}

last_link: TWO_WAY_LINKED_LIST_NODE[E_]

Void when empty or gives access to the last element.
mem_idx: INTEGER_32
mem_lnk: TWO_WAY_LINKED_LIST_NODE[E_]

To speed up accessing, mem_idx and mem_lnk is the memory of the last access done.

{ANY}

make

Make an empty list
is_empty: BOOLEAN

Is the hoard empty ?

See also count.
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.
add (element: E_, 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.
remove_first

Remove the first element of the collection.
remove (index: INTEGER_32)

Remove the item at position index.
first: E_

The very first item.
last: E_

The last item.
item (index: INTEGER_32): E_

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

Make element the item at index i.
count: INTEGER_32

Number of available items in the hoard.
set_all_with (v: E_)

Set all items with value v.
copy (other: TWO_WAY_LINKED_LIST [E_])

Reinitialize by copying all the items of other.
fast_is_equal (other: TWO_WAY_LINKED_LIST [E_]): BOOLEAN

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

Do both collections have the same lower, upper, and items?
index_of (x: 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_index_of (x: 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.
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).
from_collection (model: TRAVERSABLE[E_])

Initialize the current object with the contents of model.
slice (low: INTEGER_32, up: INTEGER_32): TWO_WAY_LINKED_LIST [E_]

New collection consisting of items at indexes in [min..max].
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.
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).
all_default: BOOLEAN

Do all items have their type's default value?
remove_last

Remove the last item.
replace_all (old_value: E_, new_value: E_)

Replace all occurrences of the element old_value by new_value using is_equal for comparison.
fast_replace_all (old_value: E_, new_value: E_)

Replace all occurrences of the element old_value by new_value using basic = for comparison.
reverse

Reverse the order of the elements.
new_iterator: ITERATOR[E_]

{}

go_item (index: INTEGER_32)
free_nodes: WEAK_REFERENCE[TWO_WAY_LINKED_LIST_NODE[E_]]

If any, they are ready to be recycled.
common_free_nodes: DICTIONARY[WEAK_REFERENCE[ANY_TWO_WAY_LINKED_LIST_NODE], STRING]
dispose_node (node: TWO_WAY_LINKED_LIST_NODE[E_]): TWO_WAY_LINKED_LIST_NODE[E_]

Add node in the free_nodes list.
new_node (e: E_, previous: TWO_WAY_LINKED_LIST_NODE[E_], next: TWO_WAY_LINKED_LIST_NODE[E_]): TWO_WAY_LINKED_LIST_NODE[E_]

Recycle from free_nodes or create a new one.

Accessing:

{ANY}

infix "@" (i: INTEGER_32): E_

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

Writing:

{ANY}

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:

{ANY}

append_collection (other: COLLECTION[E_])

Append other to Current.
append_traversable (other: TRAVERSABLE[E_])

Append other to Current.

Removing:

{ANY}

remove_head (n: INTEGER_32)

Remove the n elements of the collection.
remove_tail (n: INTEGER_32)

Remove the last n item(s).

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}

is_equal_map (other: TWO_WAY_LINKED_LIST [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:

{ANY}

move (lower_index: INTEGER_32, upper_index: INTEGER_32, distance: INTEGER_32)

Move range lower_index ..

Implement manifest generic creation:

{}

manifest_semicolon_check: BOOLEAN
manifest_put (index: INTEGER_32, element: ANY)

{ANY}

enumerate: ENUMERATE[E_]

Other features:

{ANY}

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

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}

lower: INTEGER_32

Minimum index.
upper: INTEGER_32

Maximum index.
valid_index (i: INTEGER_32): BOOLEAN

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

Looking and Searching:

{ANY}

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.