+
Point of view
All features
class PERMUT
Summary
top
Direct parents
Inherit list: COMPARABLE, FAST_ARRAY
Class invariant
top
Overview
top
Creation features
{ANY}
Features
{ANY}
{ANY}
  • is_equal (other: PERMUT): BOOLEAN
    Is other attached to an object considered equal to current object?
  • infix "<=" (other: PERMUT): BOOLEAN
    Is Current less than or equal other?
  • infix ">" (other: PERMUT): BOOLEAN
    Is Current strictly greater than other?
  • infix ">=" (other: PERMUT): BOOLEAN
    Is Current greater than or equal than other?
  • in_range (lower: PERMUT, upper: PERMUT): BOOLEAN
    Return True if Current is in range [lower..upper]
    See also min, max, compare.
  • compare (other: PERMUT): INTEGER_32
    If current object equal to other, 0 if smaller, -1; if greater, 1.
  • three_way_comparison (other: PERMUT): INTEGER_32
    If current object equal to other, 0 if smaller, -1; if greater, 1.
  • min (other: PERMUT): PERMUT
    Minimum of Current and other.
  • max (other: PERMUT): PERMUT
    Maximum of Current and other.
  • bounded_by (a_min: PERMUT, a_max: PERMUT): PERMUT
    A value that is equal to Current if it is between the limits set by a_min and a_max.
{ANY}
Creation and modification:
{ANY}
Modification:
{ANY}
Implementation of deferred:
{ANY}
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):
{}
Accessing:
{ANY}
Writing:
{ANY}
Adding:
{ANY}
Removing:
{ANY}
Looking and Searching:
{ANY}
Looking and comparison:
{ANY}
Other features:
{ANY}
Implement manifest generic creation:
{}
{ANY}
Other features:
{ANY}
Agent-based features:
{ANY}
Printing:
{ANY}
{ANY}
{}
Agent-based features:
{ANY}
{}
Indexing:
{ANY}
Accessing:
{ANY}
{ARRAYED_COLLECTION, ARRAYED_COLLECTION_HANDLER}
{ANY}
Interfacing with C:
{ANY}
{ARRAYED_COLLECTION}
{}
infix "<" (other: PERMUT): BOOLEAN
effective function
{ANY}
top
Is Current strictly less than other?
See also >, <=, >=, min, max.
require
  • other_exists: other /= Void
ensure
  • asymmetric: Result implies not other < Current
is_equal (other: PERMUT): BOOLEAN
effective function
{ANY}
top
Is other attached to an object considered equal to current object?
require
  • other /= Void
ensure
  • trichotomy: Result = not Current < other and not other < Current
  • commutative: generating_type = other.generating_type implies Result = other.is_equal(Current)
infix "<=" (other: PERMUT): BOOLEAN
effective function
{ANY}
top
Is Current less than or equal other?
See also >=, <, >, min, max.
require
  • other_exists: other /= Void
ensure
  • definition: Result = Current < other or is_equal(other)
infix ">" (other: PERMUT): BOOLEAN
effective function
{ANY}
top
Is Current strictly greater than other?
See also <, >=, <=, min, max.
require
  • other_exists: other /= Void
ensure
  • definition: Result = other < Current
infix ">=" (other: PERMUT): BOOLEAN
effective function
{ANY}
top
Is Current greater than or equal than other?
See also <=, >, <, min, max.
require
  • other_exists: other /= Void
ensure
  • definition: Result = other <= Current
in_range (lower: PERMUT, upper: PERMUT): BOOLEAN
effective function
{ANY}
top
Return True if Current is in range [lower..upper]
See also min, max, compare.
ensure
  • Result = Current >= lower and Current <= upper
compare (other: PERMUT): INTEGER_32
effective function
{ANY}
top
If current object equal to other, 0 if smaller, -1; if greater, 1.
See also min, max, in_range.
require
  • other_exists: other /= Void
ensure
  • equal_zero: Result = 0 = is_equal(other)
  • smaller_negative: Result = -1 = Current < other
  • greater_positive: Result = 1 = Current > other
three_way_comparison (other: PERMUT): INTEGER_32
effective function
{ANY}
top
If current object equal to other, 0 if smaller, -1; if greater, 1.
See also min, max, in_range.
require
  • other_exists: other /= Void
ensure
  • equal_zero: Result = 0 = is_equal(other)
  • smaller_negative: Result = -1 = Current < other
  • greater_positive: Result = 1 = Current > other
min (other: PERMUT): PERMUT
effective function
{ANY}
top
Minimum of Current and other.
See also max, in_range.
require
  • other /= Void
ensure
  • Result <= Current and then Result <= other
  • compare(Result) = 0 or else other.compare(Result) = 0
max (other: PERMUT): PERMUT
effective function
{ANY}
top
Maximum of Current and other.
See also min, in_range.
require
  • other /= Void
ensure
  • Result >= Current and then Result >= other
  • compare(Result) = 0 or else other.compare(Result) = 0
bounded_by (a_min: PERMUT, a_max: PERMUT): PERMUT
effective function
{ANY}
top
A value that is equal to Current if it is between the limits set by a_min and a_max.
Otherwise it's a_min if Current is smaller or a_max if Current is greater It's a shortcut for Current.min(a_max).max(a_min) also known as "clamp" in the widespread C library Glib
ensure
  • correctness: Result.in_range(a_min, a_max)
lower: INTEGER_32
is 0
constant attribute
{ANY}
top
Frozen lower bound.
default_create
effective procedure
{ANY}
top
Create a new with empty FAST_ARRAY with capacity 32.
make (new_count: INTEGER_32)
effective procedure
{ANY}
top
Make array with range [0 .. new_count - 1].
When new_count = 0 the array is empty.
require
  • new_count >= 0
ensure
with_capacity (needed_capacity: INTEGER_32)
effective procedure
{ANY}
top
Create an empty array with at least needed_capacity.
require
  • needed_capacity >= 0
ensure
resize (new_count: INTEGER_32)
effective procedure
{ANY}
top
Resize the array.
When new_count is greater than count, new positions are initialized with appropriate default values.
require
  • new_count >= 0
ensure
is_empty: BOOLEAN
effective function
{ANY}
top
Is the hoard empty ?
See also count.
ensure
  • definition: Result = count = 0
item (i: INTEGER_32): E_
effective function
{ANY}
top
Item at the corresponding index i.
See also lower, upper, valid_index.
require
      • valid_index(i)
      • valid_index(i)
      • valid_index(i)
      • valid_index(i)
put (element: E_, i: INTEGER_32)
effective procedure
{ANY}
top
Make element the item at index i.
See also lower, upper, valid_index, item, swap, force.
require
    • valid_index(i)
    • valid_index(i)
ensure
  • item(i) = element
  • count = old count
add_first (element: E_)
effective procedure
{ANY}
top
Add a new item in first position : count is increased by one and all other items are shifted right.
See also add_last, first, last, add.
ensure
  • first = element
  • count = 1 + old count
  • lower = old lower
  • upper = 1 + old upper
add_last (element: E_)
effective procedure
{ANY}
top
Add a new item at the end : count is increased by one.
See also add_first, last, first, add.
ensure
  • last = element
  • count = 1 + old count
  • lower = old lower
  • upper = 1 + old upper
count: INTEGER_32
effective function
{ANY}
top
Number of available items in the hoard.
See also is_empty
ensure
  • Result >= 0
clear_count
effective procedure
{ANY}
top
Discard all items (is_empty is True after that call).
If possible, the actual implementation supposed to keep its internal storage area in order to refill Current in an efficient way.
See also clear_count_and_capacity.
ensure
clear_count_and_capacity
effective procedure
{ANY}
top
Discard all items (is_empty is True after that call).
If possible, the actual implementation supposed to release its internal storage area for this memory to be used by other objects.
See also clear_count.
ensure
copy (other: PERMUT)
effective procedure
{ANY}
top
Copy other onto Current.
require
    • not immutable
    • same_dynamic_type(other)
      • not immutable
      • same_dynamic_type(other)
        • not immutable
        • same_dynamic_type(other)
        • not immutable
        • same_dynamic_type(other)
ensure
  • is_equal(other)
set_all_with (v: E_)
effective procedure
{ANY}
top
Set all items with value v.
See also set_slice_with.
ensure
  • count = old count
from_collection (model: TRAVERSABLE[E_])
effective procedure
{ANY}
top
Initialize the current object with the contents of model.
require
    • model /= Void
    • useful_work: model /= Current
    • model /= Void
    • useful_work: model /= Current
ensure
  • count = model.count
fast_is_equal (other: PERMUT): BOOLEAN
effective function
{ANY}
top
Do both collections have the same lower, upper, and items?
The basic = is used for comparison of items.
See also is_equal, same_items.
ensure
  • Result implies lower = other.lower and upper = other.upper
all_default: BOOLEAN
effective function
{ANY}
top
Do all items have their type's default value?
Note: for non Void items, the test is performed with the is_default predicate.
See also clear_all.
occurrences (element: E_): INTEGER_32
effective function
{ANY}
top
Number of occurrences of element using is_equal for comparison.
See also fast_occurrences, index_of.
ensure
  • Result >= 0
fast_occurrences (element: E_): INTEGER_32
effective function
{ANY}
top
Number of occurrences of element using basic = for comparison.
See also occurrences, index_of.
ensure
  • Result >= 0
first_index_of (element: E_): INTEGER_32
effective function
{ANY}
top
Give the index of the first occurrence of element using is_equal for comparison.
Answer upper + 1 when element is not inside.
See also fast_first_index_of, index_of, last_index_of, reverse_index_of.
ensure
  • definition: Result = index_of(element, lower)
index_of (element: E_, start_index: INTEGER_32): INTEGER_32
effective function
{ANY}
top
Using is_equal for comparison, gives the index of the first occurrence of element at or after start_index.
Return upper + 1 if the search for element failed.
See also fast_index_of, reverse_index_of, first_index_of.
ensure
  • Result.in_range(start_index, upper + 1)
  • valid_index(Result) implies (create {SAFE_EQUAL}).test(element, item(Result))
reverse_index_of (element: E_, start_index: INTEGER_32): INTEGER_32
effective function
{ANY}
top
Using is_equal for comparison, gives the index of the first occurrence of element at or before start_index.
Search is done in reverse direction, which means from the start_index down to the lower index . Answer lower -1 when the search fail.
See also fast_reverse_index_of, last_index_of, index_of.
require
    • valid_index(start_index)
    • valid_index(start_index)
ensure
  • Result.in_range(lower - 1, start_index)
  • valid_index(Result) implies item(Result).is_equal(element)
fast_first_index_of (element: E_): INTEGER_32
effective function
{ANY}
top
Give the index of the first occurrence of element using basic = for comparison.
Answer upper + 1 when element is not inside.
See also first_index_of, last_index_of, fast_last_index_of.
ensure
  • definition: Result = fast_index_of(element, lower)
fast_index_of (element: E_, start_index: INTEGER_32): INTEGER_32
effective function
{ANY}
top
Using basic = for comparison, gives the index of the first occurrence of element at or after start_index.
Answer upper + 1 when element when the search fail.
See also index_of, fast_reverse_index_of, fast_first_index_of.
ensure
  • Result.in_range(start_index, upper + 1)
  • valid_index(Result) implies element = item(Result)
fast_reverse_index_of (element: E_, start_index: INTEGER_32): INTEGER_32
effective function
{ANY}
top
Using basic = comparison, gives the index of the first occurrence of element at or before start_index.
Search is done in reverse direction, which means from the start_index down to the lower index . Answer lower -1 when the search fail.
See also reverse_index_of, fast_index_of, fast_last_index_of.
require
    • valid_index(start_index)
    • valid_index(start_index)
ensure
  • Result.in_range(lower - 1, start_index)
  • valid_index(Result) implies item(Result) = element
subarray (min: INTEGER_32, max: INTEGER_32): PERMUT
effective function
{ANY}
top
New collection consisting of items at indexes in [min .. max].
Result has the same dynamic type as Current. See also slice.
require
  • lower <= min
  • max <= upper
  • min <= max + 1
ensure
  • same_dynamic_type(Result)
  • Result.count = max - min + 1
  • Result.lower = min or Result.lower = 0
slice (min: INTEGER_32, max: INTEGER_32): PERMUT
effective function
{ANY}
top
New collection consisting of items at indexes in [min..max].
Result has the same dynamic type as Current. The lower index of the Result is the same as lower.
See also from_collection, move, replace_all.
require
    • lower <= min
    • max <= upper
    • min <= max + 1
    • lower <= min
    • max <= upper
    • min <= max + 1
ensure
  • same_dynamic_type(Result)
  • Result.count = max - min + 1
  • Result.lower = lower
force (element: E_, index: INTEGER_32)
effective procedure
{ANY}
top
Make element the item at index, enlarging the collection if necessary (new bounds except index are initialized with default values).
See also put, item, swap.
require
    • index >= lower
    • index >= lower
ensure
  • upper = index.max(old upper)
  • item(index) = element
remove_first
effective procedure
{ANY}
top
Remove the first element of the collection.
See also remove_last, remove, remove_head.
require
    • not is_empty
    • not is_empty
ensure
  • lower = old lower
  • count = old count - 1
  • lower = old lower + 1 xor upper = old upper - 1
remove_head (n: INTEGER_32)
effective procedure
{ANY}
top
Remove the n elements of the collection.
See also remove_tail, remove, remove_first.
require
    • n > 0 and n <= count
    • n > 0 and n <= count
ensure
  • count = old count - n
  • lower = old lower + n xor upper = old upper - n
remove (index: INTEGER_32)
effective procedure
{ANY}
top
Remove the item at position index.
Followings items are shifted left by one position.
See also remove_first, remove_head, remove_tail, remove_last.
require
    • valid_index(index)
    • valid_index(index)
ensure
  • count = old count - 1
  • upper = old upper - 1
new_iterator: ITERATOR[E_]
effective function
{ANY}
top
ensure
  • Result /= Void
  • Result.generation = generation
mark_native_arrays
effective procedure
{}
top
For performance reasons, the unused area of storage is always left as it is when some elements are removed.
No time is lost to clean the released area with a Void or a 0 value. (Look for example the remove_last implementation.) Thus, the unused area of storage may contains references of actually unreachable objects. The following mark_native_arrays actually replace the default behavior (the call is automatic) in order to mark only reachable objects.
manifest_make (needed_capacity: INTEGER_32)
effective procedure
{}
top
Manifest creation of a FAST_ARRAY[E_].
require
  • needed_capacity > 0
manifest_put (index: INTEGER_32, element: E_)
effective procedure
{}
top
require
    • index >= 0
    • index >= 0
infix "@" (i: INTEGER_32): E_
frozen
effective function
{ANY}
top
The infix notation which is actually just a synonym for item.
See also item.
require ensure
  • definition: Result = item(i)
swap (i1: INTEGER_32, i2: INTEGER_32)
effective procedure
{ANY}
top
Swap item at index i1 with item at index i2.
See also item, put.
require ensure
set_slice_with (v: ANY, lower_index: INTEGER_32, upper_index: INTEGER_32)
effective procedure
{ANY}
top
Set all items in range [lower_index .. upper_index] with v.
See also set_all_with.
require ensure
clear_all
effective procedure
{ANY}
top
Set every item to its default value.
The count is not affected.
See also clear, all_default.
ensure
add (element: ANY, index: INTEGER_32)
deferred procedure
{ANY}
top
Add a new element at rank index : count is increased by one and range [index .. upper] is shifted right by one position.
See also add_first, add_last, append_collection.
require ensure
append_collection (other: COLLECTION[E_])
effective procedure
{ANY}
top
Append other to Current.
This feature is obsolete: Use `append_traversable' instead.
append_traversable (other: TRAVERSABLE[E_])
effective procedure
{ANY}
top
Append other to Current.
See also add_last, add_first, add.
require
  • other /= Void
ensure
remove_last
deferred procedure
{ANY}
top
Remove the last item.
See also remove_first, remove, remove_tail.
require ensure
remove_tail (n: INTEGER_32)
deferred procedure
{ANY}
top
Remove the last n item(s).
See also remove_head, remove, remove_last.
require ensure
has (x: ANY): BOOLEAN
effective function
{ANY}
top
Look for x using is_equal for comparison.
See also fast_has, index_of, fast_index_of.
ensure
  • definition: Result = valid_index(first_index_of(x))
fast_has (x: ANY): BOOLEAN
effective function
{ANY}
top
Look for x using basic = for comparison.
See also has, fast_index_of, index_of.
ensure
  • definition: Result = valid_index(fast_first_index_of(x))
last_index_of (element: ANY): INTEGER_32
effective function
{ANY}
top
Using is_equal for comparison, gives the index of the last occurrence of element at or before upper.
Search is done in reverse direction, which means from the upper down to the lower index . Answer lower -1 when the search fail.
See also fast_last_index_of, reverse_index_of, index_of.
ensure
  • definition: Result = reverse_index_of(element, upper)
fast_last_index_of (element: ANY): INTEGER_32
effective function
{ANY}
top
Using basic = for comparison, gives the index of the last occurrence of element at or before upper.
Search is done in reverse direction, which means from the upper down to the lower index . Answer lower -1 when the search fail.
See also fast_reverse_index_of, last_index_of.
ensure
  • definition: Result = fast_reverse_index_of(element, upper)
is_equal_map (other: PERMUT): BOOLEAN
effective function
{ANY}
top
Do both collections have the same lower, upper, and items?
This feature is obsolete: Use `is_equal' instead.
same_items (other: COLLECTION[E_]): BOOLEAN
effective function
{ANY}
top
Do both collections have the same items?
The basic = is used for comparison of items and indices are not considered (for example this routine may yield True with Current indexed in range [1..2] and other indexed in range [2..3]).
See also is_equal, fast_is_equal.
require
  • other /= Void
ensure
replace_all (old_value: ANY, new_value: ANY)
deferred procedure
{ANY}
top
Replace all occurrences of the element old_value by new_value using is_equal for comparison.
See also fast_replace_all, move.
ensure
fast_replace_all (old_value: ANY, new_value: ANY)
deferred procedure
{ANY}
top
Replace all occurrences of the element old_value by new_value using basic = for comparison.
See also replace_all, move.
ensure
move (lower_index: INTEGER_32, upper_index: INTEGER_32, distance: INTEGER_32)
effective procedure
{ANY}
top
Move range lower_index ..
upper_index by distance positions. Negative distance moves towards lower indices. Free places get default values.
See also slice, replace_all.
require ensure
reverse
deferred procedure
{ANY}
top
Reverse the order of the elements.
ensure
manifest_semicolon_check: BOOLEAN
is False
constant attribute
{}
top
enumerate: ENUMERATE[E_]
effective function
{ANY}
top
get_new_iterator: ITERATOR[E_]
frozen
effective function
{ANY}
top
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}
top
Apply action to every item of Current.
See also for_all, exists, aggregate.
require
  • action /= Void
for_all (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN
effective function
{ANY}
top
Do all items satisfy test?
See also for_each, exists, aggregate.
require
  • test /= Void
exists (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN
effective function
{ANY}
top
Does at least one item satisfy test?
See also for_each, for_all, aggregate.
require
  • test /= Void
aggregate (action: FUNCTION[TUPLE[TUPLE 2[E_, E_], E_]], initial: E_): E_
effective function
{ANY}
top
Aggregate all the elements starting from the initial value.
See also for_each, for_all, exists.
require
  • action /= Void
out_in_tagged_out_memory
effective procedure
{ANY}
top
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}
top
next_generation
effective procedure
{}
top
ensure
do_all (action: ROUTINE[TUPLE[TUPLE 1[E_]]])
frozen
effective procedure
{ANY}
top
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_agent2 (a: ROUTINE[TUPLE[TUPLE 1[E_]]], e: E_)
frozen
effective procedure
{}
top
upper: INTEGER_32
deferred function
{ANY}
top
Maximum index.
See also lower, valid_index, item.
valid_index (i: INTEGER_32): BOOLEAN
effective function
{ANY}
top
True when i is valid (i.e., inside actual bounds).
See also lower, upper, item.
ensure
first: E_
deferred function
{ANY}
top
The very first item.
See also last, item.
require ensure
last: E_
deferred function
{ANY}
top
The last item.
See also first, item.
require ensure
storage: NATIVE_ARRAY[E_]
writable attribute
{ARRAYED_COLLECTION, ARRAYED_COLLECTION_HANDLER}
top
Internal access to storage location.
from_external (a_storage: POINTER, a_capacity: INTEGER_32)
effective procedure
{ARRAYED_COLLECTION, ARRAYED_COLLECTION_HANDLER}
top
require
  • a_capacity > 0 implies a_storage.is_not_null
ensure
capacity: INTEGER_32
writable attribute
{ANY}
top
Internal storage capacity in number of item.
to_external: POINTER
effective function
{ANY}
top
Gives C access into the internal storage of the ARRAY.
Result is pointing the element at index lower.
NOTE: do not free/realloc the Result. Resizing of the array 
      can makes this pointer invalid.
require ensure
  • Result.is_not_null
set_upper (new_upper: INTEGER_32)
effective procedure
{ARRAYED_COLLECTION}
top
mark_item (native_array: NATIVE_ARRAY[E_], index: INTEGER_32)
{}
top
To be used _only_ inside the definition of mark_native_arrays.
Forces the garbage collector to continue the marking process on the index-th element of the native_array. The element at index can be Void or not Void (the Void-ness test performed inside the mark_item itself).