+
Point of view
All features
class TYPEDEFS
Summary
A dictionary of C_TYPEDEFs accessible by their names The contained typedefs will be wrapped together as dummy queries into a deferred class When the wrappers generator command is invoked with the proper flag ("--standard-typedefs" ) it will also emit the queries for C types that have different sizes on different architectures and for the type definition of C99 standard. Each query is named like a C typedef and its Result type is the Eiffel equivalent of the fundamental type the typedef refers to. For example: gsize: INTEGER_64
   -- typedef unsigned long int gsize;
do
end
Those queries shall never be invoked but rather used in other
features as anchors like: do_stuff (a_size: like gsize)
Direct parents
Inherit list: LINKED_LIST
Insert list: SHARED_COLLECTIONS, SHARED_SETTINGS
Class invariant
Overview
Creation features
{ANY}
Features
{ANY}
Actual size queries
{}
{}
{}
{LINKED_LIST, ITERATOR_ON_LINKED_LIST}
  • first_link: LINKED_LIST_NODE[E_]
    Void when empty or gives access to the first element.
{LINKED_LIST}
{ANY}
{}
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}
Looking and Searching:
{ANY}
Implement manifest generic creation:
{}
{ANY}
Plugin
{ANY}
Syntactic sugar
{ANY}
Type mangling
{}
Auxiliary features
{}
Constants
{}
{}
{}
Buffers Temporary buffers used to build enumerations and structures external classes
{}
writable attribute
{ANY}
emit_wrappers
effective procedure
{ANY}
emit_variable_sized_typedefs
effective procedure
{ANY}
Emit dummy queries useful for anchored declarations (i.e. "like long") for C types that can have different sizes on different architectures.
emit_standard_typedefs
effective procedure
{ANY}
long_int_size: INTEGER_32
{}
long_unsigned_int_size: INTEGER_32
{}
size_t_size: INTEGER_32
{}
ssize_t_size: INTEGER_32
{}
ptrdiff_t_size: INTEGER_32
{}
int8_t_size: INTEGER_32
{}
uint8_t_size: INTEGER_32
{}
int16_t_size: INTEGER_32
{}
uint16_t_size: INTEGER_32
{}
int32_t_size: INTEGER_32
{}
uint32_t_size: INTEGER_32
{}
int64_t_size: INTEGER_32
{}
uint64_t_size: INTEGER_32
{}
intptr_t_size: INTEGER_32
{}
uintptr_t_size: INTEGER_32
{}
int_least8_t_size: INTEGER_32
{}
uint_least8_t_size: INTEGER_32
{}
int_least16_t_size: INTEGER_32
{}
uint_least16_t_size: INTEGER_32
{}
int_least32_t_size: INTEGER_32
{}
uint_least32_t_size: INTEGER_32
{}
int_least64_t_size: INTEGER_32
{}
uint_least64_t_size: INTEGER_32
{}
int_fast8_t_size: INTEGER_32
{}
uint_fast8_t_size: INTEGER_32
{}
int_fast16_t_size: INTEGER_32
{}
uint_fast16_t_size: INTEGER_32
{}
int_fast32_t_size: INTEGER_32
{}
uint_fast32_t_size: INTEGER_32
{}
int_fast64_t_size: INTEGER_32
{}
uint_fast64_t_size: INTEGER_32
{}
intmax_t_size: INTEGER_32
{}
uintmax_t_size: INTEGER_32
{}
_inline_agent1 (a_typedef: C_TYPEDEF)
frozen
effective procedure
{}
default_create
effective procedure
{}
Default creation method.
first_link: LINKED_LIST_NODE[E_]
writable attribute
Void when empty or gives access to the first element.
last_link: LINKED_LIST_NODE[E_]
writable attribute
Void when empty or gives access to the last element.
mem_idx: INTEGER_32
writable attribute
mem_lnk: LINKED_LIST_NODE[E_]
writable attribute
To speed up accessing, mem_idx and mem_lnk is the memory of the last access done.
make
effective procedure
{ANY}
Make an empty list
is_empty: BOOLEAN
effective function
{ANY}
Is the hoard empty ?
See also count.
add_first (element: E_)
effective procedure
{ANY}
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}
Add a new item at the end : count is increased by one.
add (element: E_, index: INTEGER_32)
effective procedure
{ANY}
Add a new element at rank index : count is increased by one and range [index .. upper] is shifted right by one position.
remove_first
effective procedure
{ANY}
Remove the first element of the collection.
remove (index: INTEGER_32)
effective procedure
{ANY}
Remove the item at position index.
first: E_
effective function
{ANY}
The very first item.
last: E_
effective function
{ANY}
The last item.
item (index: INTEGER_32): E_
effective function
{ANY}
Item at the corresponding index i.
put (element: E_, index: INTEGER_32)
effective procedure
{ANY}
Make element the item at index i.
count: INTEGER_32
effective function
{ANY}
Number of available items in the hoard.
set_all_with (v: E_)
effective procedure
{ANY}
Set all items with value v.
copy (other: TYPEDEFS)
effective procedure
{ANY}
Reinitialize by copying all the items of other.
fast_is_equal (other: TYPEDEFS): BOOLEAN
effective function
{ANY}
Do both collections have the same lower, upper, and items?
is_equal (other: TYPEDEFS): BOOLEAN
effective function
{ANY}
Do both collections have the same lower, upper, and items?
index_of (x: E_, start_index: INTEGER_32): INTEGER_32
effective function
{ANY}
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}
Using is_equal for comparison, gives the index of the first occurrence of element at or before start_index.
fast_index_of (x: E_, start_index: INTEGER_32): INTEGER_32
effective function
{ANY}
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}
Using basic = comparison, gives the index of the first occurrence of element at or before start_index.
clear_count
effective procedure
{ANY}
Discard all items (is_empty is True after that call).
clear_count_and_capacity
effective procedure
{ANY}
Discard all items (is_empty is True after that call).
from_collection (model: TRAVERSABLE[E_])
effective procedure
{ANY}
Initialize the current object with the contents of model.
slice (low: INTEGER_32, up: INTEGER_32): TYPEDEFS
effective function
{ANY}
New collection consisting of items at indexes in [min..max].
occurrences (element: E_): INTEGER_32
effective function
{ANY}
Number of occurrences of element using is_equal for comparison.
fast_occurrences (element: E_): INTEGER_32
effective function
{ANY}
Number of occurrences of element using basic = for comparison.
force (element: E_, index: INTEGER_32)
effective procedure
{ANY}
Make element the item at index, enlarging the collection if necessary (new bounds except index are initialized with default values).
all_default: BOOLEAN
effective function
{ANY}
Do all items have their type's default value?
remove_last
effective procedure
{ANY}
Remove the last item.
replace_all (old_value: E_, new_value: E_)
effective procedure
{ANY}
Replace all occurrences of the element old_value by new_value using is_equal for comparison.
fast_replace_all (old_value: E_, new_value: E_)
effective procedure
{ANY}
Replace all occurrences of the element old_value by new_value using basic = for comparison.
new_iterator: ITERATOR[E_]
effective function
{ANY}
reverse
effective procedure
{ANY}
Reverse the order of the elements.
go_item (i: INTEGER_32)
effective procedure
{}
free_nodes: WEAK_REFERENCE[LINKED_LIST_NODE[E_]]
writable attribute
{}
If any, they are ready to be recycled.
once function
{}
dispose_node (node: LINKED_LIST_NODE[E_]): LINKED_LIST_NODE[E_]
effective function
{}
Add node in the free_nodes list.
new_node (e: E_, next: LINKED_LIST_NODE[E_]): LINKED_LIST_NODE[E_]
effective function
{}
Recycle from free_nodes or create a new one.
infix "@" (i: INTEGER_32): E_
frozen
effective function
{ANY}
The infix notation which is actually just a synonym for item.
swap (i1: INTEGER_32, i2: INTEGER_32)
effective procedure
{ANY}
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}
Set all items in range [lower_index .. upper_index] with v.
clear_all
effective procedure
{ANY}
Set every item to its default value.
append_collection (other: COLLECTION[E_])
effective procedure
{ANY}
Append other to Current.
append_traversable (other: TRAVERSABLE[E_])
effective procedure
{ANY}
Append other to Current.
remove_head (n: INTEGER_32)
deferred procedure
{ANY}
Remove the n elements of the collection.
remove_tail (n: INTEGER_32)
deferred procedure
{ANY}
Remove the last n item(s).
has (x: ANY): BOOLEAN
effective function
{ANY}
Look for x using is_equal for comparison.
fast_has (x: ANY): BOOLEAN
effective function
{ANY}
Look for x using basic = for comparison.
last_index_of (element: ANY): INTEGER_32
effective function
{ANY}
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}
Using basic = for comparison, gives the index of the last occurrence of element at or before upper.
is_equal_map (other: TYPEDEFS): BOOLEAN
effective function
{ANY}
Do both collections have the same lower, upper, and items?
same_items (other: COLLECTION[E_]): BOOLEAN
effective function
{ANY}
Do both collections have the same items?
move (lower_index: INTEGER_32, upper_index: INTEGER_32, distance: INTEGER_32)
effective procedure
{ANY}
Move range lower_index ..
manifest_semicolon_check: BOOLEAN
is False
constant attribute
{}
manifest_put (index: INTEGER_32, element: ANY)
deferred procedure
{}
enumerate: ENUMERATE[E_]
effective function
{ANY}
get_new_iterator: ITERATOR[E_]
frozen
effective function
{ANY}
for_each (action: PROCEDURE[TUPLE[TUPLE 1[E_]]])
effective procedure
{ANY}
Apply action to every item of Current.
for_all (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN
effective function
{ANY}
Do all items satisfy test?
exists (test: FUNCTION[TUPLE[TUPLE 1[E_]]]): BOOLEAN
effective function
{ANY}
Does at least one item satisfy test?
aggregate (action: FUNCTION[TUPLE[TUPLE 2[E_, E_], E_]], initial: E_): E_
effective function
{ANY}
Aggregate all the elements starting from the initial value.
out_in_tagged_out_memory
effective procedure
{ANY}
Append terse printable representation of current object in tagged_out_memory.
generation: INTEGER_32
writable attribute
{ANY}
next_generation
effective procedure
{}
do_all (action: ROUTINE[TUPLE[TUPLE 1[E_]]])
frozen
effective procedure
{ANY}
Apply action to every item of Current.
_inline_agent2 (a: ROUTINE[TUPLE[TUPLE 1[E_]]], e: E_)
frozen
effective procedure
{}
lower: INTEGER_32
deferred function
{ANY}
Minimum index.
upper: INTEGER_32
deferred function
{ANY}
Maximum index.
valid_index (i: INTEGER_32): BOOLEAN
effective function
{ANY}
True when i is valid (i.e., inside actual bounds).
first_index_of (element: ANY): INTEGER_32
deferred function
{ANY}
Give the index of the first occurrence of element using is_equal for comparison.
fast_first_index_of (element: ANY): INTEGER_32
deferred function
{ANY}
Give the index of the first occurrence of element using basic = for comparison.
manifest_make (needed_capacity: INTEGER_32)
effective procedure
{}
Manifest creation of a list of items of type E_.
settings: SETTINGS
once function
{ANY}
The singleton to access all the shared settings
directory: STRING
effective function
{ANY}
Shortcut for settings.directory
include: TEXT_FILE_WRITE
once function
{ANY}
once function
{ANY}
verbose: BOOLEAN
effective function
{ANY}
global: BOOLEAN
effective function
{ANY}
dequalify (an_id: UNICODE_STRING): UNICODE_STRING
effective function
{}
an_id without the type qualifier used by GccXml to mark the identification labels.
log (a_string: ABSTRACT_STRING)
effective procedure
{}
buffer: FORMATTER
once function
{}
Buffer to render the text of the feature currently being wrapped (a function call, a structure or an enumeration).
formatter: FORMATTER
once function
{}
Shared formatter used to format various strings.
comment: STRING
is " -- "
constant attribute
{}
variadic_function_note: STRING
is " (variadic call) "
constant attribute
{}
unwrappable_function_note: STRING
is " -- Unwrappable function obsolete "Unwrappable C function" "
constant attribute
{}
expanded_class: STRING
is "expanded class "
constant attribute
{}
deferred_class: STRING
is "deferred class "
constant attribute
{}
inherits_string: STRING
is " insert ANY undefine is_equal, copy end "
constant attribute
{}
queries_header: STRING
is "feature {} -- Low-level queries "
constant attribute
{}
setters_header: STRING
is "feature {} -- Low-level setters "
constant attribute
{}
externals_header: STRING
is "feature {} -- External calls "
constant attribute
{}
typedefs_features_header: STRING
is "feature {ANY} -- C type definitions (typedefs) "
constant attribute
{}
footer: STRING
is "end "
constant attribute
{}
automatically_generated_header: STRING
is "-- This file has been created by wrappers_generator. -- Any change will be lost by the next execution of the tool. "
constant attribute
{}
automatically_generated_c_file: STRING
is "/* ** This file has been created by wrappers_generator. ** Any change will be lost by the next execution of the tool. */ "
constant attribute
{}
automatically_patched_header: STRING
is "-- Th file has been automatically created combining the output file -- of wrappers_generator #(1) -- with the differences patches found into #(2) -- Any change will be lost by the next execution of the tool. "
constant attribute
{}
once function
{}
once function
{}
once function
{}
functions: LINKED_LIST[C_FUNCTION]
once function
{}
once function
{}
once function
{}
typedefs: TYPEDEFS
once function
{}
once function
{}
perhaps its a dictionary of WRAPPER_FEATURE or WRAPPABLE_NODE
variables: LINKED_LIST[C_VARIABLE]
once function
{}
once function
{}
flag_enums: WORDS
once function
{}
Enumerations that will be forcefully wrapped as a flag.
avoided_symbols: WORDS
once function
{}
Symbols that will not be wrapped.
queries: FORMATTER
once function
{}
setters: FORMATTER
once function
{}
low_level_values: FORMATTER
once function
{}
validity_query: FORMATTER
once function
{}