+
Point of view
All features
deferred class SET [E_]
Summary
Definition of a mathematical set of objects. All common operations on mathematical sets are available.
Well known implementations are HASHED_SET and AVL_SET.
Direct parents
Inherit list: TRAVERSABLE
Insert list: SAFE_EQUAL
Known children
Inherit list: ABSTRACT_AVL_SET, ABSTRACT_HASHED_SET
Overview
Features
Counting:
{ANY}
{ANY}
Add new item e to the set.
Same job as add, but uses basic = for comparison.
• remove (e: E_)
Remove item e from the set: the mathematical definition of removing from a set is followed.
• fast_remove (e: E_)
Same job as remove, but uses basic = for comparison.
• clear_count
Empty the current set (is_empty is True after that call).
• clear_count_and_capacity
Empty the current set (is_empty is True after that call).
Looking and searching:
{ANY}
To provide iterating facilities:
{ANY}
Mathematical operations:
{ANY}
• union (other: SET [E_])
Make the union of the Current set with other.
• fast_union (other: SET [E_])
Make the union of the Current set with other.
• infix "+" (other: SET [E_]): SET [E_]
Return the union of the Current set with other.
• intersection (other: SET [E_])
Make the intersection of the Current set with other.
• fast_intersection (other: SET [E_])
Make the intersection of the Current set with other.
• infix "^" (other: SET [E_]): SET [E_]
Return the intersection of the Current set with other.
• minus (other: SET [E_])
Make the set Current - other.
• fast_minus (other: SET [E_])
Make the set Current - other.
• infix "-" (other: SET [E_]): SET [E_]
Return the set Current - other.
Comparison:
{ANY}
{ANY}
• copy (other: SET [E_])
Copy 'other' into the current set
• from_collection (model: TRAVERSABLE[E_])
{}
Implement manifest generic creation:
{}
{ANY}
Other features:
{ANY}
Agent-based features:
{ANY}
Printing:
{ANY}
{ANY}
{}
Counting:
{ANY}
Agent-based features:
{ANY}
{}
Indexing:
{ANY}
{ANY}
• test (e1: E_, e2: E_): BOOLEAN
In order to avoid run-time type errors, feature safe_equal calls is_equal only when e1 and e2 have exactly the same dynamic type.
• safe_equal (e1: E_, e2: E_): BOOLEAN
In order to avoid run-time type errors, feature safe_equal calls is_equal only when e1 and e2 have exactly the same dynamic type.
is_empty: BOOLEAN
effective function
{ANY}
Is the set empty?
ensure
• definition: Result = count = 0
deferred procedure
{ANY}
Add new item e to the set.
The mathematical definition of adding in a set is followed, i.e. the element e is added only and only if it is not yet present in the set. As this add feature is actually using is_equal, you may consider to use fast_add for expanded objects as well while trying to get the very best performances.
require
• e /= Void
ensure
deferred procedure
{ANY}
Same job as add, but uses basic = for comparison.
require
• e /= Void
ensure
remove (e: E_)
deferred procedure
{ANY}
Remove item e from the set: the mathematical definition of removing from a set is followed.
require
• e /= Void
ensure
fast_remove (e: E_)
deferred procedure
{ANY}
Same job as remove, but uses basic = for comparison.
require
• e /= Void
ensure
clear_count
deferred procedure
{ANY}
Empty the current set (is_empty is True after that call).
If possible, the actual implementation is supposed to keep its internal storage area in order to refill Current in an efficient way. See also clear_count_and_capacity to select the most appropriate.
ensure
clear_count_and_capacity
deferred procedure
{ANY}
Empty the current set (is_empty is True after that call).
If possible, the actual implementation is supposed to release its internal storage area for this memory to be used by other objects. See also clear_count to select the most appropriate.
ensure
has (e: E_): BOOLEAN
deferred function
{ANY}
Is element e in the set?
As this query is actually using is_equal, you may consider to use fast_has for expanded objects as well while trying to get the very best performances.
require
• e /= Void
ensure
fast_has (e: E_): BOOLEAN
deferred function
{ANY}
Is element e actually stored in the set?
Warning: this query is using basic = for comparison. See also has when dealing with reference types.
require
• e /= Void
ensure
reference_at (e: E_): E_
deferred function
{ANY}
Non Void when e is in the set.
In such a situation, Result is the object which is actually stored in the Current set (see ensure assertion).
require
• e /= Void
• elements_are_not_expanded: Result = Void
ensure
• has(e) implies Result.is_equal(e)
lower: INTEGER_32
is 1
constant attribute
{ANY}
Minimum index.
upper: INTEGER_32
effective function
{ANY}
Maximum index.
ensure
item (index: INTEGER_32): E_
deferred function
{ANY}
Item at the corresponding index i.
SETs are intrinsically unordered, so there is no guarantee that item(i) after performing an add or remove operation is related in any way to item(i) before that operation.
require
• valid_index(index)
ensure
first: E_
effective function
{ANY}
The very first item.
require
• not is_empty
ensure
• definition: Result = item(lower)
last: E_
effective function
{ANY}
The last item.
require
• not is_empty
ensure
• definition: Result = item(upper)
new_iterator: ITERATOR[E_]
effective function
{ANY}
ensure
• Result /= Void
• Result.generation = generation
union (other: SET [E_])
effective procedure
{ANY}
Make the union of the Current set with other.
require
• other /= Void
ensure
fast_union (other: SET [E_])
effective procedure
{ANY}
Make the union of the Current set with other.
require
• other /= Void
ensure
infix "+" (other: SET [E_]): SET [E_]
effective function
{ANY}
Return the union of the Current set with other.
require
• other /= Void
ensure
intersection (other: SET [E_])
effective procedure
{ANY}
Make the intersection of the Current set with other.
require
• other /= Void
ensure
fast_intersection (other: SET [E_])
effective procedure
{ANY}
Make the intersection of the Current set with other.
require
• other /= Void
ensure
infix "^" (other: SET [E_]): SET [E_]
effective function
{ANY}
Return the intersection of the Current set with other.
require
• other /= Void
ensure
minus (other: SET [E_])
effective procedure
{ANY}
Make the set Current - other.
require
• other /= Void
ensure
fast_minus (other: SET [E_])
effective procedure
{ANY}
Make the set Current - other.
require
• other /= Void
ensure
infix "-" (other: SET [E_]): SET [E_]
effective function
{ANY}
Return the set Current - other.
require
• other /= Void
ensure
is_subset_of (other: SET [E_]): BOOLEAN
effective function
{ANY}
Is the Current set a subset of other?
require
• other /= Void
ensure
is_disjoint_from (other: SET [E_]): BOOLEAN
effective function
{ANY}
Is the Current set disjoint from other ?
require
• other /= Void
ensure
is_equal (other: SET [E_]): BOOLEAN
effective function
{ANY}
Is the Current set equal to other?
require
• other /= Void
• other /= Void
• other /= Void
ensure
• double_inclusion: Result = is_subset_of(other) and other.is_subset_of(Current)
• commutative: generating_type = other.generating_type implies Result = other.is_equal(Current)
copy (other: SET [E_])
effective procedure
{ANY}
Copy 'other' into the current set
require
• not immutable
• same_dynamic_type(other)
• not immutable
• same_dynamic_type(other)
• not immutable
• same_dynamic_type(other)
ensure
• is_equal(other)
from_collection (model: TRAVERSABLE[E_])
effective procedure
{ANY}
require
• model /= Void
make
deferred procedure
{}
Creation of an empty SET.
ensure
manifest_make (needed_capacity: INTEGER_32)
effective procedure
{}
Manifest creation of a SET.
manifest_put (index: INTEGER_32, element: E_)
effective procedure
{}
manifest_semicolon_check: BOOLEAN
is False
constant attribute
{}
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.
for_each (action: PROCEDURE[TUPLE[TUPLE 1[E_]]])
effective procedure
{ANY}
Apply action to every item of Current.
require
• action /= Void
for_all (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN
effective function
{ANY}
Do all items satisfy test?
require
• test /= Void
exists (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN
effective function
{ANY}
Does at least one item satisfy test?
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.
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.
ensure
• Result >= 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
{}
valid_index (i: INTEGER_32): BOOLEAN
effective function
{ANY}
True when i is valid (i.e., inside actual bounds).