+
Point of view
All features
class RECYCLING_POOL [R_ -> RECYCLABLE]
Summary
top
RECYCLABLE objects container.
Useful to implement recycling support in libraries.
Has no sense for expanded types (it will not even compile).
This class is designed to work with and without the garbage collector. It takes advantage of the GC if it is used, but it also minimises the memory footprint when the GC is not used.
See also STRING_RECYCLING_POOL, especially tuned for STRING usage.
Direct parents
Insert list: ANY, STACK
Class invariant
top
Overview
top
Creation features
{ANY}
{ANY}
Features
{ANY}
  • item: R_
    Returns a recycled object, if there is one to be obtained.
  • recycle (an_item: R_)
    Stores the object as being reusable.
{}
  • mark_native_arrays
    For performance reasons, the unused area of storage is always left as it is when some elements are removed.
{}
{ANY}
Creation and modification:
{ANY}
Modification:
{ANY}
Implementation of deferred:
{ANY}
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}
{}
item: R_
effective function
{ANY}
top
Returns a recycled object, if there is one to be obtained.
recycle (an_item: R_)
effective procedure
{ANY}
top
Stores the object as being reusable.
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.
make
effective procedure
{}
top
new_iterator: ITERATOR[E_]
effective function
{}
top
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.
with_capacity (needed_capacity: INTEGER_32)
effective procedure
{ANY}
top
Create an empty array with at least needed_capacity.
resize (new_count: INTEGER_32)
effective procedure
{ANY}
top
Resize the array.
is_empty: BOOLEAN
effective function
{ANY}
top
Is the hoard empty ?
See also count.
put (element: E_, i: INTEGER_32)
effective procedure
{ANY}
top
Make element the item at index i.
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.
add_last (element: E_)
effective procedure
{ANY}
top
Add a new item at the end : count is increased by one.
count: INTEGER_32
effective function
{ANY}
top
Number of available items in the hoard.
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).
copy (other: RECYCLING_POOL [R_ -> RECYCLABLE])
effective procedure
{ANY}
top
Copy other onto Current.
set_all_with (v: E_)
effective procedure
{ANY}
top
Set all items with value v.
from_collection (model: TRAVERSABLE[E_])
effective procedure
{ANY}
top
Initialize the current object with the contents of model.
fast_is_equal (other: RECYCLING_POOL [R_ -> RECYCLABLE]): BOOLEAN
effective function
{ANY}
top
Do both collections have the same lower, upper, and items?
is_equal (other: RECYCLING_POOL [R_ -> RECYCLABLE]): BOOLEAN
effective function
{ANY}
top
Do both collections have the same lower, upper, and items?
all_default: BOOLEAN
effective function
{ANY}
top
Do all items have their type's default value?
occurrences (element: E_): INTEGER_32
effective function
{ANY}
top
Number of occurrences of element using is_equal for comparison.
fast_occurrences (element: E_): INTEGER_32
effective function
{ANY}
top
Number of occurrences of element using basic = for comparison.
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.
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.
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.
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.
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.
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.
subarray (min: INTEGER_32, max: INTEGER_32): RECYCLING_POOL [R_ -> RECYCLABLE]
effective function
{ANY}
top
New collection consisting of items at indexes in [min .. max].
slice (min: INTEGER_32, max: INTEGER_32): RECYCLING_POOL [R_ -> RECYCLABLE]
effective function
{ANY}
top
New collection consisting of items at indexes in [min..max].
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).
remove_first
effective procedure
{ANY}
top
Remove the first element of the collection.
remove_head (n: INTEGER_32)
effective procedure
{ANY}
top
Remove the n elements of the collection.
remove (index: INTEGER_32)
effective procedure
{ANY}
top
Remove the item at position index.
manifest_make (needed_capacity: INTEGER_32)
effective procedure
{}
top
Manifest creation of a FAST_ARRAY[E_].
manifest_put (index: INTEGER_32, element: E_)
effective procedure
{}
top
infix "@" (i: INTEGER_32): E_
frozen
effective function
{ANY}
top
The infix notation which is actually just a synonym for collection_item.
swap (i1: INTEGER_32, i2: INTEGER_32)
effective procedure
{ANY}
top
Swap item at index i1 with item at index i2.
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.
clear_all
effective procedure
{ANY}
top
Set every item to its default value.
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.
append_collection (other: COLLECTION[E_])
effective procedure
{ANY}
top
Append other to Current.
append_traversable (other: TRAVERSABLE[E_])
effective procedure
{ANY}
top
Append other to Current.
remove_last
deferred procedure
{ANY}
top
Remove the top item.
remove_tail (n: INTEGER_32)
deferred procedure
{ANY}
top
Remove the last n item(s).
has (x: ANY): BOOLEAN
effective function
{ANY}
top
Look for x using is_equal for comparison.
fast_has (x: ANY): BOOLEAN
effective function
{ANY}
top
Look for x using basic = for comparison.
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.
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.
is_equal_map (other: RECYCLING_POOL [R_ -> RECYCLABLE]): BOOLEAN
effective function
{ANY}
top
Do both collections have the same lower, upper, and items?
same_items (other: COLLECTION[E_]): BOOLEAN
effective function
{ANY}
top
Do both collections have the same items?
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.
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.
move (lower_index: INTEGER_32, upper_index: INTEGER_32, distance: INTEGER_32)
effective procedure
{ANY}
top
Move range lower_index ..
reverse
deferred procedure
{ANY}
top
Reverse the order of the elements.
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
for_each (action: PROCEDURE[TUPLE[TUPLE 1[E_]]])
effective procedure
{ANY}
top
Apply action to every item of Current.
for_all (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN
effective function
{ANY}
top
Do all items satisfy test?
exists (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN
effective function
{ANY}
top
Does at least one item satisfy test?
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.
out_in_tagged_out_memory
effective procedure
{ANY}
top
Append terse printable representation of current object in tagged_out_memory.
generation: INTEGER_32
writable attribute
{ANY}
top
next_generation
effective procedure
{}
top
do_all (action: ROUTINE[TUPLE[TUPLE 1[E_]]])
frozen
effective procedure
{ANY}
top
Apply action to every item of Current.
_inline_agent1 (a: ROUTINE[TUPLE[TUPLE 1[E_]]], e: E_)
frozen
effective procedure
{}
top
upper: INTEGER_32
deferred function
{ANY}
top
Maximum index.
valid_index (i: INTEGER_32): BOOLEAN
effective function
{ANY}
top
True when i is valid (i.e., inside actual bounds).
first: E_
deferred function
{ANY}
top
The very first item.
last: E_
deferred function
{ANY}
top
The top item.
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
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.
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.