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