    indexing
    	description: "A sequence of actions to be performed on call"
    	legal: "See notice at end of class."
    	instructions: "[
    		Use features inherited from LIST to add/remove actions.
    		An action is a procedure of ANY class that takes EVENT_DATA.
    		When call is called the actions in the list will be executed
    		in order stating at first.
    		An action may call abort which will cause call to stop executing
    		actions in the sequence. (Until the next call to call).
    		Descendants may redefine `initialize' to arrange for call to
    		be called by an event source.
    		Use block, pause, flush and resume to change the behavior
    		of call.
    		eg.
    		 birthday_data: TUPLE [INTEGER, STRING] -- (age, name)
    		 birthday_actions: ACTIONS_SEQUENCE [like birthday_data]
    		 create birthday_actions.make ("birthday", <<"age","name">>)
    		 send_card (age: INTEGER, name, from: STRING) is ...
    		 buy_gift (age: INTEGER, name, gift, from: STRING) is ...
    		 birthday_actions.extend (agent send_card (?, ?, "Sam")
    		 birthday_actions.extend (agent buy_gift (?, ?, "Wine", "Sam")
    		 birthday_actions.call ([35, "Julia"])
    		 causes call to: send_card (35, "Julia", "Sam")
    		                 buy_gift (35, "Julia", "Wine", "Sam")
    	]"
    	status: "See notice at end of class."
    	keywords: "event, action"
    	date: "$Date: 2006-01-22 18:25:44 -0800 (Sun, 22 Jan 2006) $"
    	revision: "$Revision: 56675 $"

    class interface
    	ACTION_SEQUENCE [EVENT_DATA -> TUPLE create default_create end]

    create
    	default_create
    			-- Begin in Normal_state.

    	make

    create {ACTION_SEQUENCE}
    	array_make (min_index, max_index: INTEGER_32)
    			-- Allocate array; set index interval to
    			-- `min_index' .. `max_index'; set all values to default.
    			-- (Make array empty if `min_index' = `max_index' + 1).
    			-- (from ARRAY)
    		require -- from ARRAY
    			valid_bounds: min_index <= max_index + 1
    		ensure -- from ARRAY
    			lower_set: lower = min_index
    			upper_set: upper = max_index
    			items_set: all_default

    	arrayed_list_make (n: INTEGER_32)
    			-- Allocate list with `n' items.
    			-- (`n' may be zero for empty list.)
    			-- (from ARRAYED_LIST)
    		require -- from ARRAYED_LIST
    			valid_number_of_items: n >= 0
    		ensure -- from ARRAYED_LIST
    			correct_position: before
    			is_empty: is_empty

    	make_filled (n: INTEGER_32)
    			-- Allocate list with `n' items.
    			-- (`n' may be zero for empty list.)
    			-- This list will be full.
    			-- (from ARRAYED_LIST)
    		require -- from ARRAYED_LIST
    			valid_number_of_items: n >= 0
    		ensure -- from ARRAYED_LIST
    			correct_position: before
    			filled: full

    feature -- Initialization

    	arrayed_list_make (n: INTEGER_32)
    			-- Allocate list with `n' items.
    			-- (`n' may be zero for empty list.)
    			-- (from ARRAYED_LIST)
    		require -- from ARRAYED_LIST
    			valid_number_of_items: n >= 0
    		ensure -- from ARRAYED_LIST
    			correct_position: before
    			is_empty: is_empty

    	make_filled (n: INTEGER_32)
    			-- Allocate list with `n' items.
    			-- (`n' may be zero for empty list.)
    			-- This list will be full.
    			-- (from ARRAYED_LIST)
    		require -- from ARRAYED_LIST
    			valid_number_of_items: n >= 0
    		ensure -- from ARRAYED_LIST
    			correct_position: before
    			filled: full

    	make_from_array (a: ARRAY [PROCEDURE [ANY, EVENT_DATA]])
    			-- Create list from array `a'.
    			-- (from ARRAYED_LIST)
    		require -- from ARRAY
    			array_exists: a /= Void
    		ensure then -- from ARRAYED_LIST
    			correct_position: before
    			filled: count = a.count

    feature -- Access

    	cursor: ARRAYED_LIST_CURSOR
    			-- Current cursor position
    			-- (from ARRAYED_LIST)
    		ensure -- from CURSOR_STRUCTURE
    			cursor_not_void: Result /= Void

    	first: like item
    			-- Item at first position
    			-- (from ARRAYED_LIST)
    		require -- from CHAIN
    			not_empty: not is_empty

    	generating_type: STRING_8
    			-- Name of current object's generating type
    			-- (type of which it is a direct instance)
    			-- (from ANY)

    	generator: STRING_8
    			-- Name of current object's generating class
    			-- (base class of the type of which it is a direct instance)
    			-- (from ANY)

    	has (v: like item): BOOLEAN
    			-- Does current include `v'?
    			-- (Reference or object equality,
    			-- based on object_comparison.)
    			-- (from ARRAYED_LIST)
    		require -- from  CONTAINER
    			True
    		ensure -- from CONTAINER
    			not_found_in_empty: Result implies not is_empty

    	i_th alias "[]" (i: INTEGER_32): like item assign put_i_th
    			-- Item at `i'-th position
    			-- Was declared in ARRAYED_LIST as synonym of infix "@".
    			-- (from ARRAYED_LIST)
    		require -- from TABLE
    			valid_key: valid_index (i)

    	index: INTEGER_32
    			-- Index of item, if valid.
    			-- (from ARRAYED_LIST)

    	index_of (v: like item; i: INTEGER_32): INTEGER_32
    			-- Index of `i'-th occurrence of item identical to `v'.
    			-- (Reference or object equality,
    			-- based on object_comparison.)
    			-- 0 if none.
    			-- (from CHAIN)
    		require -- from LINEAR
    			positive_occurrences: i > 0
    		ensure -- from LINEAR
    			non_negative_result: Result >= 0

    	item: PROCEDURE [ANY, EVENT_DATA]
    			-- Current item
    			-- (from ARRAYED_LIST)
    		require -- from TRAVERSABLE
    			not_off: not off
    		require -- from ACTIVE
    			readable: readable
    		require else -- from ARRAYED_LIST
    			index_is_valid: valid_index (index)

    	last: like first
    			-- Item at last position
    			-- (from ARRAYED_LIST)
    		require -- from CHAIN
    			not_empty: not is_empty

    	name: STRING_8
    			-- Textual description.
    		ensure
    			equal_to_name_internal: equal (Result, name_internal)

    	sequential_occurrences (v: like item): INTEGER_32
    			-- Number of times `v' appears.
    			-- (Reference or object equality,
    			-- based on object_comparison.)
    			-- (from LINEAR)
    		require -- from  BAG
    			True
    		ensure -- from BAG
    			non_negative_occurrences: Result >= 0

    	infix "@" (i: INTEGER_32): like item assign put_i_th
    			-- Item at `i'-th position
    			-- Was declared in ARRAYED_LIST as synonym of i_th.
    			-- (from ARRAYED_LIST)
    		require -- from TABLE
    			valid_key: valid_index (i)

    feature -- Measurement

    	count: INTEGER_32
    			-- Number of items.
    			-- (from ARRAYED_LIST)

    	index_set: INTEGER_INTERVAL
    			-- Range of acceptable indexes
    			-- (from CHAIN)
    		require -- from  INDEXABLE
    			True
    		ensure -- from INDEXABLE
    			not_void: Result /= Void
    		ensure then -- from CHAIN
    			count_definition: Result.count = count

    	occurrences (v: like item): INTEGER_32
    			-- Number of times `v' appears.
    			-- (Reference or object equality,
    			-- based on object_comparison.)
    			-- (from CHAIN)
    		require -- from  BAG
    			True
    		require -- from  LINEAR
    			True
    		ensure -- from BAG
    			non_negative_occurrences: Result >= 0

    feature {ANY} -- Measurement

    	capacity: INTEGER_32
    			-- Number of available indices
    			-- Was declared in ARRAY as synonym of count.
    			-- (from ARRAY)
    		require -- from  BOUNDED
    			True
    		ensure then -- from ARRAY
    			consistent_with_bounds: Result = upper - lower + 1

    feature -- Comparison

    	frozen deep_equal (some: ANY; other: like arg #1): BOOLEAN
    			-- Are `some' and `other' either both void
    			-- or attached to isomorphic object structures?
    			-- (from ANY)
    		ensure -- from ANY
    			shallow_implies_deep: standard_equal (some, other) implies Result
    			both_or_none_void: (some = Void) implies (Result = (other = Void))
    			same_type: (Result and (some /= Void)) implies some.same_type (other)
    			symmetric: Result implies deep_equal (other, some)

    	frozen equal (some: ANY; other: like arg #1): BOOLEAN
    			-- Are `some' and `other' either both void or attached
    			-- to objects considered equal?
    			-- (from ANY)
    		ensure -- from ANY
    			definition: Result = (some = Void and other = Void) or else ((some /= Void and other /= Void) and then some.is_equal (other))

    	is_equal (other: like Current): BOOLEAN
    			-- Does `other' contain the same elements?
    			-- (from LIST)
    		require -- from ANY
    			other_not_void: other /= Void
    		ensure -- from ANY
    			symmetric: Result implies other.is_equal (Current)
    			consistent: standard_is_equal (other) implies Result
    		ensure then -- from LIST
    			indices_unchanged: index = old index and other.index = old other.index
    			true_implies_same_size: Result implies count = other.count

    	frozen standard_equal (some: ANY; other: like arg #1): BOOLEAN
    			-- Are `some' and `other' either both void or attached to
    			-- field-by-field identical objects of the same type?
    			-- Always uses default object comparison criterion.
    			-- (from ANY)
    		ensure -- from ANY
    			definition: Result = (some = Void and other = Void) or else ((some /= Void and other /= Void) and then some.standard_is_equal (other))

    	frozen standard_is_equal (other: like Current): BOOLEAN
    			-- Is `other' attached to an object of the same type
    			-- as current object, and field-by-field identical to it?
    			-- (from ANY)
    		require -- from ANY
    			other_not_void: other /= Void
    		ensure -- from ANY
    			same_type: Result implies same_type (other)
    			symmetric: Result implies other.standard_is_equal (Current)

    feature -- Status report

    	after: BOOLEAN
    			-- Is there no valid cursor position to the right of cursor?
    			-- (from LIST)
    		require -- from  LINEAR
    			True

    	before: BOOLEAN
    			-- Is there no valid cursor position to the left of cursor?
    			-- (from LIST)
    		require -- from  BILINEAR
    			True

    	blocked_state: INTEGER_32 is 3

    	call_is_underway: BOOLEAN
    			-- Is call currently being executed?
    		ensure
    			Result = not is_aborted_stack.is_empty

    	changeable_comparison_criterion: BOOLEAN
    			-- May object_comparison be changed?
    			-- (Answer: yes by default.)
    			-- (from CONTAINER)

    	conforms_to (other: ANY): BOOLEAN
    			-- Does type of current object conform to type
    			-- of `other' (as per Eiffel: The Language, chapter 13)?
    			-- (from ANY)
    		require -- from ANY
    			other_not_void: other /= Void

    	exhausted: BOOLEAN
    			-- Has structure been completely explored?
    			-- (from LINEAR)
    		ensure -- from LINEAR
    			exhausted_when_off: off implies Result

    	extendible: BOOLEAN is True
    			-- May new items be added? (Answer: yes.)
    			-- (from DYNAMIC_CHAIN)

    	full: BOOLEAN
    			-- Is structure filled to capacity?
    			-- (from ARRAYED_LIST)
    		require -- from  BOX
    			True

    	is_empty: BOOLEAN
    			-- Is structure empty?
    			-- (from FINITE)

    	is_inserted (v: PROCEDURE [ANY, EVENT_DATA]): BOOLEAN
    			-- Has `v' been inserted at the end by the most recent put or
    			-- extend?
    			-- (from ARRAYED_LIST)

    	isfirst: BOOLEAN
    			-- Is cursor at first position?
    			-- (from CHAIN)
    		ensure -- from CHAIN
    			valid_position: Result implies not is_empty

    	islast: BOOLEAN
    			-- Is cursor at last position?
    			-- (from CHAIN)
    		ensure -- from CHAIN
    			valid_position: Result implies not is_empty

    	normal_state: INTEGER_32 is 1

    	object_comparison: BOOLEAN
    			-- Must search operations use equal rather than `='
    			-- for comparing references? (Default: no, use `='.)
    			-- (from CONTAINER)

    	off: BOOLEAN
    			-- Is there no current item?
    			-- (from CHAIN)
    		require -- from  TRAVERSABLE
    			True

    	paused_state: INTEGER_32 is 2

    	prunable: BOOLEAN
    			-- May items be removed? (Answer: yes.)
    			-- (from ARRAYED_LIST)
    		require -- from  COLLECTION
    			True

    	readable: BOOLEAN
    			-- Is there a current item that may be read?
    			-- (from SEQUENCE)
    		require -- from  ACTIVE
    			True

    	same_type (other: ANY): BOOLEAN
    			-- Is type of current object identical to type of `other'?
    			-- (from ANY)
    		require -- from ANY
    			other_not_void: other /= Void
    		ensure -- from ANY
    			definition: Result = (conforms_to (other) and other.conforms_to (Current))

    	state: INTEGER_32
    			-- One of Normal_state Paused_state or Blocked_state

    	valid_cursor (p: CURSOR): BOOLEAN
    			-- Can the cursor be moved to position `p'?
    			-- (from ARRAYED_LIST)

    	valid_cursor_index (i: INTEGER_32): BOOLEAN
    			-- Is `i' correctly bounded for cursor movement?
    			-- (from CHAIN)
    		ensure -- from CHAIN
    			valid_cursor_index_definition: Result = ((i >= 0) and (i <= count + 1))

    	valid_index (i: INTEGER_32): BOOLEAN
    			-- Is `i' a valid index?
    			-- (from ARRAYED_LIST)
    		require -- from  TABLE
    			True
    		require -- from  TO_SPECIAL
    			True
    		ensure then -- from INDEXABLE
    			only_if_in_index_set: Result implies ((i >= index_set.lower) and (i <= index_set.upper))
    		ensure then -- from CHAIN
    			valid_index_definition: Result = ((i >= 1) and (i <= count))

    	writable: BOOLEAN
    			-- Is there a current item that may be modified?
    			-- (from SEQUENCE)
    		require -- from  ACTIVE
    			True

    feature -- Status setting

    	abort
    			-- Abort the current call.
    			-- (The current item.call will be completed.)
    		require
    			call_is_underway: call_is_underway
    		ensure
    			is_aborted_set: is_aborted_stack.item

    	block
    			-- Ignore subsequent calls.
    		ensure
    			blocked_state: state = blocked_state

    	compare_objects
    			-- Ensure that future search operations will use equal
    			-- rather than `=' for comparing references.
    			-- (from CONTAINER)
    		require -- from CONTAINER
    			changeable_comparison_criterion: changeable_comparison_criterion
    		ensure -- from CONTAINER
    			object_comparison

    	compare_references
    			-- Ensure that future search operations will use `='
    			-- rather than equal for comparing references.
    			-- (from CONTAINER)
    		require -- from CONTAINER
    			changeable_comparison_criterion: changeable_comparison_criterion
    		ensure -- from CONTAINER
    			reference_comparison: not object_comparison

    	flush
    			-- Discard any buffered calls.
    		ensure
    			call_buffer_empty: call_buffer.is_empty

    	pause
    			-- Buffer subsequent calls for later execution.
    			-- If `is_blocked' calls will simply be ignored.
    		ensure
    			paused_state: state = paused_state

    	resume
    			-- Used after block or pause to resume normal call
    			-- execution.  Executes any buffered calls.
    		ensure
    			normal_state: state = normal_state

    feature -- Cursor movement

    	back
    			-- Move cursor one position backward.
    			-- (from ARRAYED_LIST)
    		require -- from BILINEAR
    			not_before: not before

    	finish
    			-- Move cursor to last position if any.
    			-- (from ARRAYED_LIST)
    		require -- from  LINEAR
    			True
    		ensure then -- from CHAIN
    			at_last: not is_empty implies islast
    		ensure then -- from ARRAYED_LIST
    			before_when_empty: is_empty implies before

    	forth
    			-- Move cursor one position forward.
    			-- (from ARRAYED_LIST)
    		require -- from LINEAR
    			not_after: not after
    		ensure then -- from LIST
    			moved_forth: index = old index + 1

    	go_i_th (i: INTEGER_32)
    			-- Move cursor to `i'-th position.
    			-- (from ARRAYED_LIST)
    		require -- from CHAIN
    			valid_cursor_index: valid_cursor_index (i)
    		ensure -- from CHAIN
    			position_expected: index = i

    	go_to (p: CURSOR)
    			-- Move cursor to position `p'.
    			-- (from ARRAYED_LIST)
    		require -- from CURSOR_STRUCTURE
    			cursor_position_valid: valid_cursor (p)

    	move (i: INTEGER_32)
    			-- Move cursor `i' positions.
    			-- (from ARRAYED_LIST)
    		ensure -- from CHAIN
    			too_far_right: (old index + i > count) implies exhausted
    			too_far_left: (old index + i < 1) implies exhausted
    			expected_index: (not exhausted) implies (index = old index + i)

    	search (v: like item)
    			-- Move to first position (at or after current
    			-- position) where item and `v' are equal.
    			-- If structure does not include `v' ensure that
    			-- exhausted will be true.
    			-- (Reference or object equality,
    			-- based on object_comparison.)
    			-- (from ARRAYED_LIST)
    		require -- from  LINEAR
    			True
    		ensure -- from LINEAR
    			object_found: (not exhausted and object_comparison) implies equal (v, item)
    			item_found: (not exhausted and not object_comparison) implies v = item

    	start
    			-- Move cursor to first position if any.
    			-- (from ARRAYED_LIST)
    		require -- from  TRAVERSABLE
    			True
    		ensure then -- from CHAIN
    			at_first: not is_empty implies isfirst
    		ensure then -- from ARRAYED_LIST
    			after_when_empty: is_empty implies after

    feature -- Element change

    	append (s: SEQUENCE [PROCEDURE [ANY, EVENT_DATA]])
    			-- Append a copy of `s'.
    			-- (from ARRAYED_LIST)
    		require -- from SEQUENCE
    			argument_not_void: s /= Void
    		ensure -- from SEQUENCE
    			new_count: count >= old count

    	extend (v: like item)
    			-- Add `v' to end.
    			-- Do not move cursor.
    			-- Was declared in ARRAYED_LIST as synonym of force.
    			-- (from ARRAYED_LIST)
    		require -- from COLLECTION
    			extendible: extendible
    		ensure -- from COLLECTION
    			item_inserted: is_inserted (v)
    		ensure then -- from BAG
    			one_more_occurrence: occurrences (v) = old (occurrences (v)) + 1

    	fill (other: CONTAINER [PROCEDURE [ANY, EVENT_DATA]])
    			-- Fill with as many items of `other' as possible.
    			-- The representations of `other' and current structure
    			-- need not be the same.
    			-- (from CHAIN)
    		require -- from COLLECTION
    			other_not_void: other /= Void
    			extendible: extendible

    	force (v: like item)
    			-- Add `v' to end.
    			-- Do not move cursor.
    			-- Was declared in ARRAYED_LIST as synonym of extend.
    			-- (from ARRAYED_LIST)
    		require -- from SEQUENCE
    			extendible: extendible
    		ensure then -- from SEQUENCE
    			new_count: count = old count + 1
    			item_inserted: has (v)

    	merge_left (other: ARRAYED_LIST [PROCEDURE [ANY, EVENT_DATA]])
    			-- Merge `other' into current structure before cursor.
    			-- (from ARRAYED_LIST)
    		require -- from DYNAMIC_CHAIN
    			extendible: extendible
    			not_before: not before
    			other_exists: other /= Void
    			not_current: other /= Current
    		ensure -- from DYNAMIC_CHAIN
    			new_count: count = old count + old other.count
    			new_index: index = old index + old other.count
    			other_is_empty: other.is_empty

    	merge_right (other: ARRAYED_LIST [PROCEDURE [ANY, EVENT_DATA]])
    			-- Merge `other' into current structure after cursor.
    			-- (from ARRAYED_LIST)
    		require -- from DYNAMIC_CHAIN
    			extendible: extendible
    			not_after: not after
    			other_exists: other /= Void
    			not_current: other /= Current
    		ensure -- from DYNAMIC_CHAIN
    			new_count: count = old count + old other.count
    			same_index: index = old index
    			other_is_empty: other.is_empty

    	put_i_th (v: like i_th; i: INTEGER_32)
    			-- Replace `i'-th entry, if in index interval, by `v'.
    			-- (from ARRAY)
    		require -- from TABLE
    			valid_key: valid_index (i)
    		require -- from TO_SPECIAL
    			valid_index: valid_index (i)
    		ensure then -- from INDEXABLE
    			insertion_done: i_th (i) = v
    		ensure -- from TO_SPECIAL
    			inserted: array_item (i) = v

    	put (v: like item)
    			-- Replace current item by `v'.
    			-- (Synonym for replace)
    			-- (from CHAIN)
    		require -- from COLLECTION
    			extendible: extendible
    		ensure -- from COLLECTION
    			item_inserted: is_inserted (v)
    		ensure then -- from CHAIN
    			same_count: count = old count

    	put_front (v: like item)
    			-- Add `v' to the beginning.
    			-- Do not move cursor.
    			-- (from ARRAYED_LIST)
    		ensure -- from DYNAMIC_CHAIN
    			new_count: count = old count + 1
    			item_inserted: first = v

    	put_left (v: like item)
    			-- Add `v' to the left of current position.
    			-- Do not move cursor.
    			-- (from ARRAYED_LIST)
    		require -- from DYNAMIC_CHAIN
    			extendible: extendible
    			not_before: not before
    		ensure -- from DYNAMIC_CHAIN
    			new_count: count = old count + 1
    			new_index: index = old index + 1

    	put_right (v: like item)
    			-- Add `v' to the right of current position.
    			-- Do not move cursor.
    			-- (from ARRAYED_LIST)
    		require -- from DYNAMIC_CHAIN
    			extendible: extendible
    			not_after: not after
    		ensure -- from DYNAMIC_CHAIN
    			new_count: count = old count + 1
    			same_index: index = old index

    	replace (v: like first)
    			-- Replace current item by `v'.
    			-- (from ARRAYED_LIST)
    		require -- from ACTIVE
    			writable: writable
    		ensure -- from ACTIVE
    			item_replaced: item = v

    feature -- Removal

    	prune (v: like item)
    			-- Remove first occurrence of `v', if any,
    			-- after cursor position.
    			-- Move cursor to right neighbor.
    			-- (or after if no right neighbor or `v' does not occur)
    			-- (from ARRAYED_LIST)
    		require -- from COLLECTION
    			prunable: prunable

    	prune_all (v: like item)
    			-- Remove all occurrences of `v'.
    			-- (Reference or object equality,
    			-- based on object_comparison.)
    			-- (from ARRAYED_LIST)
    		require -- from COLLECTION
    			prunable: prunable
    		ensure -- from COLLECTION
    			no_more_occurrences: not has (v)
    		ensure then -- from DYNAMIC_CHAIN
    			is_exhausted: exhausted
    		ensure then -- from ARRAYED_LIST
    			is_after: after

    	remove
    			-- Remove current item.
    			-- Move cursor to right neighbor
    			-- (or after if no right neighbor)
    			-- (from ARRAYED_LIST)
    		require -- from ACTIVE
    			prunable: prunable
    			writable: writable
    		ensure then -- from DYNAMIC_LIST
    			after_when_empty: is_empty implies after
    		ensure then -- from ARRAYED_LIST
    			index: index = old index

    	remove_left
    			-- Remove item to the left of cursor position.
    			-- Do not move cursor.
    			-- (from ARRAYED_LIST)
    		require -- from DYNAMIC_CHAIN
    			left_exists: index > 1
    		ensure -- from DYNAMIC_CHAIN
    			new_count: count = old count - 1
    			new_index: index = old index - 1

    	remove_right
    			-- Remove item to the right of cursor position
    			-- Do not move cursor
    			-- (from ARRAYED_LIST)
    		require -- from DYNAMIC_CHAIN
    			right_exists: index < count
    		ensure -- from DYNAMIC_CHAIN
    			new_count: count = old count - 1
    			same_index: index = old index

    	wipe_out
    			-- Remove all items.
    			-- (from ARRAYED_LIST)
    		require -- from COLLECTION
    			prunable: prunable
    		ensure -- from COLLECTION
    			wiped_out: is_empty
    		ensure then -- from DYNAMIC_LIST
    			is_before: before

    feature -- Resizing

    	resize (new_capacity: INTEGER_32)
    			-- Resize list so that it can contain
    			-- at least `n' items. Do not lose any item.
    			-- (from ARRAYED_LIST)
    		require -- from ARRAYED_LIST
    			new_capacity_large_enough: new_capacity >= capacity
    		ensure -- from ARRAYED_LIST
    			capacity_set: capacity >= new_capacity

    feature -- Transformation

    	swap (i: INTEGER_32)
    			-- Exchange item at `i'-th position with item
    			-- at cursor position.
    			-- (from ARRAYED_LIST)
    		require -- from CHAIN
    			not_off: not off
    			valid_index: valid_index (i)
    		ensure -- from CHAIN
    			swapped_to_item: item = old i_th (i)
    			swapped_from_item: i_th (i) = old item

    feature -- Conversion

    	linear_representation: LINEAR [PROCEDURE [ANY, EVENT_DATA]]
    			-- Representation as a linear structure
    			-- (from LINEAR)
    		require -- from  CONTAINER
    			True

    feature -- Duplication

    	copy (other: like Current)
    			-- Reinitialize by copying all the items of `other'.
    			-- (This is also used by clone.)
    			-- (from ARRAY)
    		require -- from ANY
    			other_not_void: other /= Void
    			type_identity: same_type (other)
    		ensure -- from ANY
    			is_equal: is_equal (other)
    		ensure then -- from ARRAY
    			equal_areas: area.is_equal (other.area)

    	frozen deep_copy (other: like Current)
    			-- Effect equivalent to that of:
    			--		copy (`other' . deep_twin)
    			-- (from ANY)
    		require -- from ANY
    			other_not_void: other /= Void
    		ensure -- from ANY
    			deep_equal: deep_equal (Current, other)

    	frozen deep_twin: like Current
    			-- New object structure recursively duplicated from Current.
    			-- (from ANY)
    		ensure -- from ANY
    			deep_equal: deep_equal (Current, Result)

    	duplicate (n: INTEGER_32): like Current
    			-- Copy of sub-list beginning at current position
    			-- and having min (`n', count - index + 1) items.
    			-- (from ARRAYED_LIST)
    		require -- from CHAIN
    			not_off_unless_after: off implies after
    			valid_subchain: n >= 0

    	frozen standard_copy (other: like Current)
    			-- Copy every field of `other' onto corresponding field
    			-- of current object.
    			-- (from ANY)
    		require -- from ANY
    			other_not_void: other /= Void
    			type_identity: same_type (other)
    		ensure -- from ANY
    			is_standard_equal: standard_is_equal (other)

    	frozen standard_twin: like Current
    			-- New object field-by-field identical to `other'.
    			-- Always uses default copying semantics.
    			-- (from ANY)
    		ensure -- from ANY
    			standard_twin_not_void: Result /= Void
    			equal: standard_equal (Result, Current)

    	frozen twin: like Current
    			-- New object equal to `Current'
    			-- twin calls copy; to change copying/twining semantics, redefine copy.
    			-- (from ANY)
    		ensure -- from ANY
    			twin_not_void: Result /= Void
    			is_equal: Result.is_equal (Current)

    feature -- Basic operations

    	call (event_data: EVENT_DATA)
    			-- Call each procedure in order unless `is_blocked'.
    			-- If `is_paused' delay execution until resume.
    			-- Stop at current point in list on abort.
    		ensure
    			is_aborted_stack_unchanged: old is_aborted_stack.is_equal (is_aborted_stack)

    	frozen default: like Current
    			-- Default value of object's type
    			-- (from ANY)

    	frozen default_pointer: POINTER
    			-- Default value of type `POINTER'
    			-- (Avoid the need to write `p'.default for
    			-- some `p' of type `POINTER'.)
    			-- (from ANY)

    	default_rescue
    			-- Process exception for routines with no Rescue clause.
    			-- (Default: do nothing.)
    			-- (from ANY)

    	frozen do_nothing
    			-- Execute a null action.
    			-- (from ANY)

    feature -- Element Change

    	prune_when_called (an_action: like item)
    			-- Remove `an_action' after the next time it is called.
    		require
    			has (an_action)

    feature -- Event handling

    	empty_actions: ARRAYED_LIST [PROCEDURE [ANY, TUPLE]]
    			-- Actions to be performed on transition from not is_empty to is_empty.

    	not_empty_actions: ARRAYED_LIST [PROCEDURE [ANY, TUPLE]]
    			-- Actions to be performed on transition from is_empty to not is_empty.

    feature -- Iteration

    	do_all (action: PROCEDURE [ANY, TUPLE [PROCEDURE [ANY, EVENT_DATA]]])
    			-- Apply `action' to every item.
    			-- Semantics not guaranteed if `action' changes the structure;
    			-- in such a case, apply iterator to clone of structure instead.
    			-- (from LINEAR)
    		require -- from TRAVERSABLE
    			action_exists: action /= Void
    		require -- from ARRAY
    			action_not_void: action /= Void

    	do_if (action: PROCEDURE [ANY, TUPLE [PROCEDURE [ANY, EVENT_DATA]]]; test: FUNCTION [ANY, TUPLE [PROCEDURE [ANY, EVENT_DATA]], BOOLEAN])
    			-- Apply `action' to every item that satisfies `test'.
    			-- Semantics not guaranteed if `action' or `test' changes the structure;
    			-- in such a case, apply iterator to clone of structure instead.
    			-- (from LINEAR)
    		require -- from TRAVERSABLE
    			action_exists: action /= Void
    			test_exits: test /= Void
    		require -- from ARRAY
    			action_not_void: action /= Void
    			test_not_void: test /= Void

    	for_all (test: FUNCTION [ANY, TUPLE [PROCEDURE [ANY, EVENT_DATA]], BOOLEAN]): BOOLEAN
    			-- Is `test' true for all items?
    			-- Semantics not guaranteed if `test' changes the structure;
    			-- in such a case, apply iterator to clone of structure instead.
    			-- (from LINEAR)
    		require -- from TRAVERSABLE
    			test_exits: test /= Void
    		require -- from ARRAY
    			test_not_void: test /= Void
    		ensure then -- from LINEAR
    			empty: is_empty implies Result

    	there_exists (test: FUNCTION [ANY, TUPLE [PROCEDURE [ANY, EVENT_DATA]], BOOLEAN]): BOOLEAN
    			-- Is `test' true for at least one item?
    			-- Semantics not guaranteed if `test' changes the structure;
    			-- in such a case, apply iterator to clone of structure instead.
    			-- (from LINEAR)
    		require -- from TRAVERSABLE
    			test_exits: test /= Void
    		require -- from ARRAY
    			test_not_void: test /= Void

    feature -- Output

    	io: STD_FILES
    			-- Handle to standard file setup
    			-- (from ANY)

    	out: STRING_8
    			-- New string containing terse printable representation
    			-- of current object
    			-- Was declared in ANY as synonym of tagged_out.
    			-- (from ANY)

    	print (some: ANY)
    			-- Write terse external representation of `some'
    			-- on standard output.
    			-- (from ANY)

    	frozen tagged_out: STRING_8
    			-- New string containing terse printable representation
    			-- of current object
    			-- Was declared in ANY as synonym of out.
    			-- (from ANY)

    feature -- Platform

    	operating_environment: OPERATING_ENVIRONMENT
    			-- Objects available from the operating system
    			-- (from ANY)

    invariant
    	is_aborted_stack_not_void: is_aborted_stack /= Void
    	call_buffer_not_void: call_buffer /= Void
    	valid_state: state = normal_state or state = paused_state or state = blocked_state
    	call_buffer_consistent: state = normal_state implies call_buffer.is_empty
    	not_empty_actions_not_void: not_empty_actions /= Void
    	empty_actions_not_void: empty_actions /= Void

    		-- from ARRAYED_LIST
    	prunable: prunable
    	starts_from_one: lower = 1
    	empty_means_storage_empty: is_empty implies all_default

    		-- from ARRAY
    	area_exists: area /= Void
    	consistent_size: capacity = upper - lower + 1
    	non_negative_count: count >= 0
    	index_set_has_same_count: valid_index_set

    		-- from RESIZABLE
    	increase_by_at_least_one: minimal_increase >= 1

    		-- from BOUNDED
    	valid_count: count <= capacity
    	full_definition: full = (count = capacity)

    		-- from FINITE
    	empty_definition: is_empty = (count = 0)
    	non_negative_count: count >= 0

    		-- from ANY
    	reflexive_equality: standard_is_equal (Current)
    	reflexive_conformance: conforms_to (Current)

    		-- from INDEXABLE
    	index_set_not_void: index_set /= Void

    		-- from LIST
    	before_definition: before = (index = 0)
    	after_definition: after = (index = count + 1)

    		-- from CHAIN
    	non_negative_index: index >= 0
    	index_small_enough: index <= count + 1
    	off_definition: off = ((index = 0) or (index = count + 1))
    	isfirst_definition: isfirst = ((not is_empty) and (index = 1))
    	islast_definition: islast = ((not is_empty) and (index = count))
    	item_corresponds_to_index: (not off) implies (item = i_th (index))
    	index_set_has_same_count: index_set.count = count

    		-- from ACTIVE
    	writable_constraint: writable implies readable
    	empty_constraint: is_empty implies (not readable) and (not writable)

    		-- from BILINEAR
    	not_both: not (after and before)
    	before_constraint: before implies off

    		-- from LINEAR
    	after_constraint: after implies off

    		-- from TRAVERSABLE
    	empty_constraint: is_empty implies off

    		-- from DYNAMIC_CHAIN
    	extendible: extendible

    indexing
    	library: "EiffelBase: Library of reusable components for Eiffel."
    	copyright: "Copyright (c) 1984-2006, Eiffel Software and others"
    	license: "Eiffel Forum License v2 (see http://www.eiffel.com/licensing/forum.txt)"
    	source: "[
    		Eiffel Software
    		356 Storke Road, Goleta, CA 93117 USA
    		Telephone 805-685-1006, Fax 805-685-6869
    		Website http://www.eiffel.com
    		Customer support http://support.eiffel.com
    	]"

    end -- class ACTION_SEQUENCE