+
Point of view
All features
class EXT_PYTHON_DICTIONARY [V_, K_]
Summary
Associative memory. Values of type V_ are stored using Keys of type K_.
Efficient implementation of DICTIONARY using a hash_coder function on keys, using Python's algorithm.
Direct parents
Inherit list: ABSTRACT_PYTHON_DICTIONARY
Class invariant
Overview
Creation features
{ANY}
Features
{ANY}
{}
{ANY}
{ANY}
{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.
  • remove (k: K_)
    Remove entry k (which may exist or not before this call).
  • fast_remove (k: K_)
    Same job as remove, but uses basic = for comparison.
  • 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).
  • set_item (v: V_, index: INTEGER_32)
  • item (index: INTEGER_32): V_
    Item at the corresponding index i.
  • key (index: INTEGER_32): K_
  • new_iterator_on_keys: ITERATOR[K_]
  • new_iterator_on_items: ITERATOR[V_]
  • new_iterator: ITERATOR[TUPLE 2[V_, K_]]
  • 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).
  • copy (other: EXT_PYTHON_DICTIONARY [V_, K_])
    Reinitialize by copying all associations of other.
  • internal_key (k: K_): K_
    Retrieve the internal key object which correspond to the existing entry k (the one memorized into the Current dictionary).
{ABSTRACT_PYTHON_DICTIONARY}
{ANY}
{}
Implement manifest generic creation:
{}
Creation procedures
{}
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}
{ANY}
  • fast_is_equal (other: EXT_PYTHON_DICTIONARY [V_, K_]): BOOLEAN
    Do both dictionaries have the same set of associations?
  • is_equal (other: EXT_PYTHON_DICTIONARY [V_, K_]): BOOLEAN
    Do both dictionaries have the same set of associations?
  • is_equal_map (other: EXT_PYTHON_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}
hash_coder: FUNCTION[TUPLE[TUPLE 1[K_], ]]
writable attribute
{ANY}
hash_code (k: K_): INTEGER_32
effective function
{}
require
  • k /= Void
make (a_hash_coder: FUNCTION[TUPLE[TUPLE 1[K_], ]])
effective procedure
{ANY}
require
  • a_hash_coder /= Void
ensure
with_capacity (a_hash_coder: FUNCTION[TUPLE[TUPLE 1[K_], ]], medium_size: INTEGER_32)
effective procedure
{ANY}
require
  • a_hash_coder /= Void
  • medium_size > 0
ensure
Default_size: INTEGER_32
is 16
constant attribute
{ANY}
capacity: INTEGER_32
writable attribute
{ANY}
Of the storage area.
A power of two.
count: INTEGER_32
writable attribute
{ANY}
Number of available items in the hoard.
See also is_empty
ensure
  • Result >= 0
has (k: K_): BOOLEAN
effective function
{ANY}
Is there a value currently associated with key k?
See also fast_has, at.
require
  • k /= Void
at (k: K_): V_
effective function
{ANY}
Return the value associated to key k.
See also fast_at, reference_at, has.
require
  • has(k)
reference_at (k: K_): V_
effective function
{ANY}
Return Void or the value associated with key k.
Actually, this feature is useful only when the type of values (the type V_) is a reference type, to avoid using has just followed by at to get the corresponding value with the very best performances.
See also fast_reference_at, at, has.
require
  • k /= Void
  • values_are_not_expanded: Result = Void
ensure
  • has(k) implies Result = at(k)
fast_has (k: K_): BOOLEAN
effective function
{ANY}
Is there a value currently associated with key k?
Using basic = for comparison.
See also has, at, fast_at.
require
  • k /= Void
fast_at (k: K_): V_
effective function
{ANY}
Return the value associated to key k using basic = for comparison.
require
  • fast_has(k)
fast_reference_at (k: K_): V_
effective function
{ANY}
Same work as reference_at, but basic = is used for comparison.
See also reference_at, at, has.
require
  • k /= Void
  • values_are_reference: Result = Void
ensure
  • fast_has(k) implies Result = fast_at(k)
put (v: V_, k: K_)
effective procedure
{ANY}
Change some existing entry or add the new one.
If there is as yet no key k in the dictionary, enter it with item v. Otherwise overwrite the item associated with key k. As the put procedure actually uses is_equal, you may consider to use fast_put for expanded objects as well while trying to get the very best performances.
See also fast_put, add.
require
  • k /= Void
ensure
  • v = at(k)
fast_put (v: V_, k: K_)
effective procedure
{ANY}
Same job as put, but uses basic = for comparison.
If you are sure that k is not an existing entry, please consider using add to get very best performances.
See also put, add.
require
  • k /= Void
ensure
  • v = at(k)
add (v: V_, k: K_)
effective procedure
{ANY}
To add a new entry k with its associated value v.
Actually, this is equivalent to call put, but it may run a little bit faster.
See also put, fast_put.
require
  • not has(k)
ensure
  • count = 1 + old count
  • v = at(k)
remove (k: K_)
effective procedure
{ANY}
Remove entry k (which may exist or not before this call).
As the remove procedure actually uses is_equal, you may consider to use fast_remove for expanded objects as well while trying to get the very best performances.
See also fast_remove, clear_count.
require
  • k /= Void
ensure
  • not has(k)
fast_remove (k: K_)
effective procedure
{ANY}
Same job as remove, but uses basic = for comparison.
See also remove, clear_count.
require
  • k /= Void
ensure
  • not fast_has(k)
clear_count
effective procedure
{ANY}
Discard all items (is_empty is True after that call).
The internal capacity is not changed by this call.
See also clear_count_and_capacity, remove.
ensure
clear_count_and_capacity
effective procedure
{ANY}
Discard all items (is_empty is True after that call).
The internal capacity may also be reduced after this call.
See also clear_count, remove.
ensure
set_item (v: V_, index: INTEGER_32)
effective procedure
{ANY}
require
  • valid_index(index)
ensure
  • count = old count
  • v = item(index)
item (index: INTEGER_32): V_
effective function
{ANY}
Item at the corresponding index i.
See also lower, upper, valid_index.
require
  • valid_index(index)
ensure
  • Result = at(key(index))
key (index: INTEGER_32): K_
effective function
{ANY}
require
  • valid_index(index)
ensure
  • at(Result) = item(index)
new_iterator_on_keys: ITERATOR[K_]
effective function
{ANY}
ensure
  • Result /= Void
new_iterator_on_items: ITERATOR[V_]
effective function
{ANY}
ensure
  • Result /= Void
  • Result /= Void
  • Result /= Void
  • Result.generation = generation
new_iterator: ITERATOR[TUPLE 2[V_, K_]]
effective function
{ANY}
ensure
  • Result /= Void
key_map_in (buffer: COLLECTION[K_])
effective procedure
{ANY}
Append in buffer, all available keys (this may be useful to speed up the traversal).
See also item_map_in.
require
  • buffer /= Void
ensure
  • buffer.count = count + old buffer.count
item_map_in (buffer: COLLECTION[V_])
effective procedure
{ANY}
Append in buffer, all available items (this may be useful to speed up the traversal).
See also key_map_in.
require
  • buffer /= Void
ensure
  • buffer.count = count + old buffer.count
copy (other: EXT_PYTHON_DICTIONARY [V_, K_])
effective procedure
{ANY}
Reinitialize by copying all associations of other.
require
    • not immutable
    • same_dynamic_type(other)
    • not immutable
    • same_dynamic_type(other)
ensure
  • is_equal(other)
internal_key (k: K_): K_
effective function
{ANY}
Retrieve the internal key object which correspond to the existing entry k (the one memorized into the Current dictionary).
See also has, fast_has.
require
  • has(k)
ensure
  • Result.is_equal(k)
storage: NATIVE_ARRAY[PYTHON_DICTIONARY_NODE[V_, K_]]
writable attribute
ensure_capacity (new_capacity: INTEGER_32)
effective procedure
require
  • new_capacity.is_a_power_of_2
ensure
valid_internal_index (index: INTEGER_32): BOOLEAN
effective function
{ANY}
next_internal_index (index: INTEGER_32): INTEGER_32
effective function
{ANY}
require ensure
internal_index (index: INTEGER_32): INTEGER_32
effective function
{ANY}
require
index_of (k: K_): INTEGER_32
effective function
{}
require
  • k /= Void
ensure
  • positive_is_found: Result >= 0 implies Result.in_range(0, capacity - 1) and then key_safe_equal(storage.item(Result).key, k)
  • negative_is_insert_index: Result < 0 implies not storage.item(- Result - 1).is_set
fast_index_of (k: K_): INTEGER_32
effective function
{}
require
  • k /= Void
ensure
  • positive_is_found: Result >= 0 implies Result.in_range(0, capacity - 1) and then storage.item(Result).key = k
  • negative_is_insert_index: Result < 0 implies - Result - 1.in_range(0, capacity - 1) and then not storage.item(- Result - 1).is_set
stew_shift: INTEGER_8
is 5
constant attribute
{}
manifest_make (needed_capacity: INTEGER_32)
effective procedure
{}
Manifest creation of a HASHED_DICTIONARY.
create_with_capacity (new_capacity: INTEGER_32)
effective procedure
{}
require
  • new_capacity > 0
powered_capacity (medium_size: INTEGER_32): INTEGER_32
effective function
{}
ensure
  • Result >= medium_size
  • Result.is_a_power_of_2
manifest_put (index: INTEGER_32, v: V_, k: K_)
effective procedure
{}
require
manifest_semicolon_check: INTEGER_32
is 2
constant attribute
{}
Put semicolons between successive value-key pairs.
key_safe_equal (k1: K_, k2: K_): BOOLEAN
effective function
{}
Because keys are never Void, we do not rely on the SAFE_EQUAL class.
require
  • k1 /= Void
  • k2 /= Void
is_empty: BOOLEAN
effective function
{ANY}
Is it empty?
ensure
  • definition: Result = count = 0
infix "@" (k: K_): V_
frozen
effective function
{ANY}
The infix notation which is actually a synonym for at.
require ensure
  • definition: Result = at(k)
occurrences (v: V_): INTEGER_32
effective function
{ANY}
Number of occurrences using is_equal for comparison.
ensure
  • Result >= 0
fast_occurrences (v: V_): INTEGER_32
effective function
{ANY}
Number of occurrences using basic = for comparison.
See also occurrences, fast_has, has.
ensure
  • Result >= 0
key_at (v: V_): K_
effective function
{ANY}
Retrieve the key used for value v using is_equal for comparison.
See also fast_key_at, at.
require ensure
fast_key_at (v: V_): K_
effective function
{ANY}
Retrieve the key used for value v using = for comparison.
See also key_at, at.
require ensure
  • at(Result) = v
lower: INTEGER_32
is 1
constant attribute
{ANY}
Minimum index.
See also upper, valid_index, item.
upper: INTEGER_32
effective function
{ANY}
Maximum index.
See also lower, valid_index, item.
ensure
first: V_
effective function
{ANY}
The very first item.
See also last, item.
require
  • not is_empty
ensure
  • definition: Result = item(lower)
last: V_
effective function
{ANY}
The last item.
See also first, item.
require
  • not is_empty
ensure
  • definition: Result = item(upper)
keys: TRAVERSABLE[K_]
effective function
{ANY}
An iterable of this map keys
ensure
items: TRAVERSABLE[V_]
effective function
{ANY}
An iterable of this map values Usually returns Current because MAP is TRAVERSABLE.
ensure
fast_is_equal (other: EXT_PYTHON_DICTIONARY [V_, K_]): BOOLEAN
effective function
{ANY}
Do both dictionaries have the same set of associations?
Keys are compared with is_equal and values are compared with the basic = operator.
See also is_equal.
ensure
is_equal (other: EXT_PYTHON_DICTIONARY [V_, K_]): BOOLEAN
effective function
{ANY}
Do both dictionaries have the same set of associations?
Both keys and values are compared with is_equal.
See also fast_is_equal.
require
    • other /= Void
    • other /= Void
ensure
  • commutative: generating_type = other.generating_type implies Result = other.is_equal(Current)
is_equal_map (other: EXT_PYTHON_DICTIONARY [V_, K_]): BOOLEAN
effective function
{ANY}
Do both collections have the same lower, upper, and items?
This feature is obsolete: Use `is_equal' instead.
out_in_tagged_out_memory
effective procedure
{ANY}
Append terse printable representation of current object in tagged_out_memory.
require
    • locked: tagged_out_locked
    • 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))
for_each (action: PROCEDURE[TUPLE[TUPLE 2[V_, K_]]])
effective procedure
{ANY}
Apply action to every [V_, K_] associations of Current.
See also for_all, exist.
require
  • action /= Void
do_all (action: ROUTINE[TUPLE[TUPLE 2[V_, K_]]])
frozen
effective procedure
{ANY}
Apply action to every [V_, K_] associations of Current.
This feature is obsolete: This feature is not secure because it accepts a FUNCTION, the result of which is lost. Plese use `for_each` instead.
for_all (test: FUNCTION[TUPLE[TUPLE 2[V_, K_]]]): BOOLEAN
effective function
{ANY}
Do all [V_, K_] associations satisfy test?
See also for_each, exist.
require
  • test /= Void
exists (test: FUNCTION[TUPLE[TUPLE 2[V_, K_]]]): BOOLEAN
effective function
{ANY}
Does at least one [V_, K_] association satisfy test?
See also for_all, for_each.
require
  • test /= Void
aggregate (action: FUNCTION[TUPLE[TUPLE 3[V_, V_, K_], V_]], initial: V_): V_
effective function
{ANY}
Aggregate all the elements starting from the initial value.
See also for_each, for_all, exists.
require
  • action /= Void
keys_memory: DICTIONARY_KEY_TRAVERSER[V_, K_]
writable attribute
{}
_inline_agent43 (v: V_, k: K_)
frozen
effective procedure
{}
enumerate: ENUMERATE[E_]
effective function
{ANY}
get_new_iterator: ITERATOR[E_]
frozen
effective function
{ANY}
This feature is obsolete: Use `new_iterator' instead. This historical SmartEiffel feature is badly named.
generation: INTEGER_32
writable attribute
{ANY}
next_generation
effective procedure
{}
ensure
_inline_agent1 (a: ROUTINE[TUPLE[TUPLE 1[E_]]], e: E_)
frozen
effective procedure
{}
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