+
Point of view
All features
class ARRAY_DICTIONARY [V_, K_]
Summary
top
This dictionary is sorted in the order in which the keys are added. Access time is not good at all: O(n)
Direct parents
Inherit list: DICTIONARY
Class invariant
top
Overview
top
Creation features
{ANY}
Features
Basic access:
{ANY}
  • has (k: K_): BOOLEAN
    Is there a value currently associated with key k?
  • at (k: K_): V_
    Return the value associated to key k.
  • reference_at (k: K_): V_
    Return Void or the value associated with key k.
  • fast_has (k: K_): BOOLEAN
    Is there a value currently associated with key k?
  • fast_at (k: K_): V_
    Return the value associated to key k using basic = for comparison.
  • fast_reference_at (k: K_): V_
    Same work as reference_at, but basic = is used for comparison.
{ANY}
  • put (v: V_, k: K_)
    Change some existing entry or add the new one.
  • fast_put (v: V_, k: K_)
    Same job as put, but uses basic = for comparison.
  • add (v: V_, k: K_)
    To add a new entry k with its associated value v.
Removing:
{ANY}
To provide iterating facilities:
{ANY}
Other features:
{ANY}
  • internal_key (k: K_): K_
    Retrieve the internal key object which correspond to the existing entry k (the one memorized into the Current dictionary).
  • copy (other: ARRAY_DICTIONARY [V_, K_])
    Reinitialize by copying all associations of other.
{}
{ARRAY_DICTIONARY}
Implement manifest generic creation:
{}
{}
Counting:
{ANY}
Basic access:
{ANY}
  • infix "@" (k: K_): V_
    The infix notation which is actually a synonym for at.
Looking and searching some value:
{ANY}
To provide iterating facilities:
{ANY}
  • lower: INTEGER_32
    Minimum index.
  • upper: INTEGER_32
    Maximum index.
  • first: V_
    The very first item.
  • last: V_
    The last item.
  • key_map_in (buffer: COLLECTION[K_])
    Append in buffer, all available keys (this may be useful to speed up the traversal).
  • item_map_in (buffer: COLLECTION[V_])
    Append in buffer, all available items (this may be useful to speed up the traversal).
  • keys: TRAVERSABLE[K_]
    An iterable of this map keys
  • items: TRAVERSABLE[V_]
    An iterable of this map values Usually returns Current because MAP is TRAVERSABLE.
{ANY}
  • fast_is_equal (other: ARRAY_DICTIONARY [V_, K_]): BOOLEAN
    Do both dictionaries have the same set of associations?
  • is_equal (other: ARRAY_DICTIONARY [V_, K_]): BOOLEAN
    Do both dictionaries have the same set of associations?
  • is_equal_map (other: ARRAY_DICTIONARY [V_, K_]): BOOLEAN
    Do both collections have the same lower, upper, and items?
Display support:
{ANY}
Agents based features:
{ANY}
{}
{}
{ANY}
Other features:
{ANY}
{ANY}
{}
{}
Indexing:
{ANY}
has (k: K_): BOOLEAN
effective function
{ANY}
top
Is there a value currently associated with key k?
at (k: K_): V_
effective function
{ANY}
top
Return the value associated to key k.
reference_at (k: K_): V_
effective function
{ANY}
top
Return Void or the value associated with key k.
fast_has (k: K_): BOOLEAN
effective function
{ANY}
top
Is there a value currently associated with key k?
fast_at (k: K_): V_
effective function
{ANY}
top
Return the value associated to key k using basic = for comparison.
fast_reference_at (k: K_): V_
effective function
{ANY}
top
Same work as reference_at, but basic = is used for comparison.
put (v: V_, k: K_)
effective procedure
{ANY}
top
Change some existing entry or add the new one.
fast_put (v: V_, k: K_)
effective procedure
{ANY}
top
Same job as put, but uses basic = for comparison.
add (v: V_, k: K_)
effective procedure
{ANY}
top
To add a new entry k with its associated value v.
remove (k: K_)
effective procedure
{ANY}
top
Remove entry k (which may exist or not before this call).
fast_remove (k: K_)
effective procedure
{ANY}
top
Same job as remove, but uses basic = for comparison.
clear_count
effective procedure
{ANY}
top
Discard all items (is_empty is True after that call).
clear_count_and_capacity
effective procedure
{ANY}
top
Discard all items (is_empty is True after that call).
capacity: INTEGER_32
effective function
{ANY}
top
Approximation of the actual internal storage capacity.
count: INTEGER_32
effective function
{ANY}
top
Number of available items in the hoard.
set_item (v: V_, index: INTEGER_32)
effective procedure
{ANY}
top
item (index: INTEGER_32): V_
effective function
{ANY}
top
Item at the corresponding index i.
key (index: INTEGER_32): K_
effective function
{ANY}
top
new_iterator_on_items: ITERATOR[V_]
effective function
{ANY}
top
new_iterator_on_keys: ITERATOR[K_]
effective function
{ANY}
top
new_iterator: ITERATOR[TUPLE 2[V_, K_]]
effective function
{ANY}
top
internal_key (k: K_): K_
effective function
{ANY}
top
Retrieve the internal key object which correspond to the existing entry k (the one memorized into the Current dictionary).
copy (other: ARRAY_DICTIONARY [V_, K_])
effective procedure
{ANY}
top
Reinitialize by copying all associations of other.
make
effective procedure
{}
top
Creates an empty dictionary.
with_capacity (needed_capacity: INTEGER_32)
effective procedure
{}
top
keys_storage: FAST_ARRAY[K_]
writable attribute
{ARRAY_DICTIONARY}
top
items_storage: FAST_ARRAY[V_]
writable attribute
{ARRAY_DICTIONARY}
top
manifest_make (needed_capacity: INTEGER_32)
effective procedure
{}
top
Manifest creation of a dictionary.
manifest_put (index: INTEGER_32, v: V_, k: K_)
effective procedure
{}
top
manifest_semicolon_check: INTEGER_32
is 2
constant attribute
{}
top
Put semicolons between successive value-key pairs.
key_safe_equal (k1: K_, k2: K_): BOOLEAN
effective function
{}
top
Because keys are never Void, we do not rely on the SAFE_EQUAL class.
is_empty: BOOLEAN
effective function
{ANY}
top
Is it empty?
infix "@" (k: K_): V_
frozen
effective function
{ANY}
top
The infix notation which is actually a synonym for at.
occurrences (v: V_): INTEGER_32
effective function
{ANY}
top
Number of occurrences using is_equal for comparison.
fast_occurrences (v: V_): INTEGER_32
effective function
{ANY}
top
Number of occurrences using basic = for comparison.
key_at (v: V_): K_
effective function
{ANY}
top
Retrieve the key used for value v using is_equal for comparison.
fast_key_at (v: V_): K_
effective function
{ANY}
top
Retrieve the key used for value v using = for comparison.
lower: INTEGER_32
is 1
constant attribute
{ANY}
top
Minimum index.
upper: INTEGER_32
effective function
{ANY}
top
Maximum index.
first: V_
effective function
{ANY}
top
The very first item.
last: V_
effective function
{ANY}
top
The last item.
key_map_in (buffer: COLLECTION[K_])
effective procedure
{ANY}
top
Append in buffer, all available keys (this may be useful to speed up the traversal).
item_map_in (buffer: COLLECTION[V_])
effective procedure
{ANY}
top
Append in buffer, all available items (this may be useful to speed up the traversal).
keys: TRAVERSABLE[K_]
effective function
{ANY}
top
An iterable of this map keys
items: TRAVERSABLE[V_]
effective function
{ANY}
top
An iterable of this map values Usually returns Current because MAP is TRAVERSABLE.
fast_is_equal (other: ARRAY_DICTIONARY [V_, K_]): BOOLEAN
effective function
{ANY}
top
Do both dictionaries have the same set of associations?
is_equal (other: ARRAY_DICTIONARY [V_, K_]): BOOLEAN
effective function
{ANY}
top
Do both dictionaries have the same set of associations?
is_equal_map (other: ARRAY_DICTIONARY [V_, K_]): BOOLEAN
effective function
{ANY}
top
Do both collections have the same lower, upper, and items?
out_in_tagged_out_memory
effective procedure
{ANY}
top
Append terse printable representation of current object in tagged_out_memory.
for_each (action: PROCEDURE[TUPLE[TUPLE 2[V_, K_]]])
effective procedure
{ANY}
top
Apply action to every [V_, K_] associations of Current.
do_all (action: ROUTINE[TUPLE[TUPLE 2[V_, K_]]])
frozen
effective procedure
{ANY}
top
Apply action to every [V_, K_] associations of Current.
for_all (test: FUNCTION[TUPLE[TUPLE 2[V_, K_]]]): BOOLEAN
effective function
{ANY}
top
Do all [V_, K_] associations satisfy test?
exists (test: FUNCTION[TUPLE[TUPLE 2[V_, K_]]]): BOOLEAN
effective function
{ANY}
top
Does at least one [V_, K_] association satisfy test?
aggregate (action: FUNCTION[TUPLE[TUPLE 3[V_, V_, K_], V_]], initial: V_): V_
effective function
{ANY}
top
Aggregate all the elements starting from the initial value.
keys_memory: DICTIONARY_KEY_TRAVERSER[V_, K_]
writable attribute
{}
top
_inline_agent43 (v: V_, k: K_)
frozen
effective procedure
{}
top
enumerate: ENUMERATE[E_]
effective function
{ANY}
top
get_new_iterator: ITERATOR[E_]
frozen
effective function
{ANY}
top
generation: INTEGER_32
writable attribute
{ANY}
top
next_generation
effective procedure
{}
top
_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).