Automatic generation produced by ISE Eiffel

Classes Clusters Cluster hierarchy Chart Relations Text Flat Contracts Flat contracts Go to:
indexing description: "Sequential lists, without commitment to a particular representation" status: "See notice at end of class" names: list, sequence access: index, cursor, membership contents: generic date: "$Date: 2001-11-16 20:32:23 +0000 (Fri, 16 Nov 2001) $" revision: "$Revision: 51435 $" deferred class LIST [G] feature -- Access cursor: CURSOR is -- Current cursor position -- (from CURSOR_STRUCTURE) deferred end first: like item is -- Item at first position -- (from CHAIN) require -- from CHAIN not_empty: not is_empty local pos: CURSOR do pos := cursor start Result := item go_to (pos) end has (v: like item): BOOLEAN is -- Does chain include v? -- (Reference or object equality, -- based on object_comparison.) -- (from CHAIN) local pos: CURSOR do pos := cursor Result := sequential_has (v) go_to (pos) ensure -- from CONTAINER not_found_in_empty: Result implies not is_empty end i_th (i: INTEGER): like item is -- Item at i-th position -- Was declared in CHAIN as synonym of @. -- (from CHAIN) require -- from TABLE valid_key: valid_index (k) local pos: CURSOR do pos := cursor go_i_th (i) Result := item go_to (pos) end index: INTEGER is -- Current cursor index -- (from CHAIN) deferred end index_of (v: like item; i: INTEGER): INTEGER is -- 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 local pos: CURSOR do pos := cursor Result := sequential_index_of (v, i) go_to (pos) ensure -- from LINEAR non_negative_result: Result >= 0 end item: G is -- Item at current position -- (from TRAVERSABLE) require -- from TRAVERSABLE not_off: not off require -- from ACTIVE readable: readable deferred end last: like item is -- Item at last position -- (from CHAIN) require -- from CHAIN not_empty: not is_empty local pos: CURSOR do pos := cursor finish Result := item go_to (pos) end sequential_occurrences (v: G): INTEGER is -- Number of times v appears. -- (Reference or object equality, -- based on object_comparison.) -- (from LINEAR) do from start search (v) until exhausted loop Result := Result + 1 forth search (v) end ensure -- from BAG non_negative_occurrences: Result >= 0 end infix "@" (i: INTEGER): like item is -- Item at i-th position -- Was declared in CHAIN as synonym of i_th. -- (from CHAIN) require -- from TABLE valid_key: valid_index (k) local pos: CURSOR do pos := cursor go_i_th (i) Result := item go_to (pos) end feature {NONE} -- Access sequential_has (v: like item): BOOLEAN is -- Does structure include an occurrence of v? -- (Reference or object equality, -- based on object_comparison.) -- (from LINEAR) do start if not off then search (v) end Result := not exhausted ensure -- from CONTAINER not_found_in_empty: Result implies not is_empty end sequential_index_of (v: like item; i: INTEGER): INTEGER is -- Index of i-th occurrence of v. -- 0 if none. -- (Reference or object equality, -- based on object_comparison.) -- (from LINEAR) require -- from LINEAR positive_occurrences: i > 0 local occur, pos: INTEGER do if object_comparison and v /= void then from start pos := 1 until off or (occur = i) loop if item /= void and then v.is_equal (item) then occur := occur + 1 end forth pos := pos + 1 end else from start pos := 1 until off or (occur = i) loop if item = v then occur := occur + 1 end forth pos := pos + 1 end end if occur = i then Result := pos - 1 end ensure -- from LINEAR non_negative_result: Result >= 0 end sequential_search (v: like item) is -- Move to first position (at or after current -- position) where item and v are equal. -- (Reference or object equality, -- based on object_comparison.) -- If no such position ensure that exhausted will be true. -- (from LINEAR) do if object_comparison and v /= void then from until exhausted or else (item /= void and then v.is_equal (item)) loop forth end else from until exhausted or else v = item loop forth end end 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 end feature -- Measurement count: INTEGER is -- Number of items -- (from FINITE) deferred end index_set: INTEGER_INTERVAL is -- Range of acceptable indexes -- (from CHAIN) do create Result.make (1, count) ensure -- from INDEXABLE not_void: Result /= void ensure then -- from CHAIN count_definition: Result.count = count end occurrences (v: like item): INTEGER is -- Number of times v appears. -- (Reference or object equality, -- based on object_comparison.) -- (from CHAIN) local pos: CURSOR do pos := cursor Result := sequential_occurrences (v) go_to (pos) ensure -- from BAG non_negative_occurrences: Result >= 0 end occurrences (v: like item): INTEGER is -- Number of times v appears. -- (Reference or object equality, -- based on object_comparison.) -- (from CHAIN) local pos: CURSOR do pos := cursor Result := sequential_occurrences (v) go_to (pos) ensure -- from BAG non_negative_occurrences: Result >= 0 end feature -- Comparison is_equal (other: like Current): BOOLEAN is -- Does other contain the same elements? require -- from ANY other_not_void: other /= void local c1, c2: CURSOR do if Current = other then Result := True else Result := (is_empty = other.is_empty) and (object_comparison = other.object_comparison) if Result and not is_empty then c1 ?= cursor c2 ?= other.cursor check cursors_exist: c1 /= void and c2 /= void end from start other.start until after or not Result loop if object_comparison then Result := equal (item, other.item) else Result := (item = other.item) end forth other.forth end go_to (c1) other.go_to (c2) elseif is_empty and other.is_empty and object_comparison = other.object_comparison then Result := True end end ensure -- from ANY symmetric: Result implies other.is_equal (Current) consistent: standard_is_equal (other) implies Result ensure then indices_unchanged: index = old index and other.index = old other.index true_implies_same_size: Result implies count = other.count end feature -- Status report after: BOOLEAN is -- Is there no valid cursor position to the right of cursor? do Result := (index = count + 1) end before: BOOLEAN is -- Is there no valid cursor position to the left of cursor? do Result := (index = 0) end changeable_comparison_criterion: BOOLEAN is -- May object_comparison be changed? -- (Answer: yes by default.) -- (from CONTAINER) do Result := True end empty: BOOLEAN is obsolete "ELKS 2000: Use `is_empty' instead" -- Is there no element? -- (from CONTAINER) do Result := is_empty end exhausted: BOOLEAN is -- Has structure been completely explored? -- (from LINEAR) do Result := off ensure -- from LINEAR exhausted_when_off: off implies Result end extendible: BOOLEAN is -- May new items be added? -- (from COLLECTION) deferred end full: BOOLEAN is -- Is structure filled to capacity? -- (from BOX) deferred end is_empty: BOOLEAN is -- Is structure empty? -- (from FINITE) do Result := (count = 0) end is_inserted (v: G): BOOLEAN is -- Has v been inserted by the most recent insertion? -- (By default, the value returned is equivalent to calling -- `has (v)'. However, descendants might be able to provide more -- efficient implementations.) -- (from COLLECTION) do Result := has (v) end isfirst: BOOLEAN is -- Is cursor at first position? -- (from CHAIN) do Result := not is_empty and (index = 1) ensure -- from CHAIN valid_position: Result implies not is_empty end islast: BOOLEAN is -- Is cursor at last position? -- (from CHAIN) do Result := not is_empty and (index = count) ensure -- from CHAIN valid_position: Result implies not is_empty end object_comparison: BOOLEAN -- Must search operations use equal rather than = -- for comparing references? (Default: no, use =.) -- (from CONTAINER) off: BOOLEAN is -- Is there no current item? -- (from CHAIN) do Result := (index = 0) or (index = count + 1) end prunable: BOOLEAN is -- May items be removed? -- (from COLLECTION) deferred end readable: BOOLEAN is -- Is there a current item that may be read? -- (from SEQUENCE) do Result := not off end valid_cursor (p: CURSOR): BOOLEAN is -- Can the cursor be moved to position p? -- (from CURSOR_STRUCTURE) deferred end valid_cursor_index (i: INTEGER): BOOLEAN is -- Is i correctly bounded for cursor movement? -- (from CHAIN) do Result := (i >= 0) and (i <= count + 1) ensure -- from CHAIN valid_cursor_index_definition: Result = ((i >= 0) and (i <= count + 1)) end valid_index (i: INTEGER): BOOLEAN is -- Is i within allowable bounds? -- (from CHAIN) do Result := (i >= 1) and (i <= count) 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)) end writable: BOOLEAN is -- Is there a current item that may be modified? -- (from SEQUENCE) do Result := not off end feature -- Status setting compare_objects is -- Ensure that future search operations will use equal -- rather than = for comparing references. -- (from CONTAINER) require -- from CONTAINER changeable_comparison_criterion do object_comparison := True ensure -- from CONTAINER object_comparison end compare_references is -- Ensure that future search operations will use = -- rather than equal for comparing references. -- (from CONTAINER) require -- from CONTAINER changeable_comparison_criterion do object_comparison := False ensure -- from CONTAINER reference_comparison: not object_comparison end feature -- Cursor movement back is -- Move to previous position. -- (from BILINEAR) require -- from BILINEAR not_before: not before deferred end finish is -- Move cursor to last position. -- (No effect if empty) -- (from CHAIN) do if not is_empty then go_i_th (count) end ensure then -- from CHAIN at_last: not is_empty implies islast end forth is -- Move to next position; if no next position, -- ensure that exhausted will be true. require -- from LINEAR not_after: not after deferred ensure then moved_forth: index = old index + 1 end go_i_th (i: INTEGER) is -- Move cursor to i-th position. -- (from CHAIN) require -- from CHAIN valid_cursor_index: valid_cursor_index (i) do move (i - index) ensure -- from CHAIN position_expected: index = i end go_to (p: CURSOR) is -- Move cursor to position p. -- (from CURSOR_STRUCTURE) require -- from CURSOR_STRUCTURE cursor_position_valid: valid_cursor (p) deferred end move (i: INTEGER) is -- Move cursor i positions. The cursor -- may end up off if the absolute value of i -- is too big. -- (from CHAIN) local counter, pos, final: INTEGER do if i > 0 then from until (counter = i) or else off loop forth counter := counter + 1 end elseif i < 0 then final := index + i; if final <= 0 then start; back else from start pos := 1 until pos = final loop forth pos := pos + 1 end end end 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) end search (v: like item) is -- 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 BILINEAR) do if before and not is_empty then forth end sequential_search (v) 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 end start is -- Move cursor to first position. -- (No effect if empty) -- (from CHAIN) do if not is_empty then go_i_th (1) end ensure then -- from CHAIN at_first: not is_empty implies isfirst end feature -- Element change append (s: SEQUENCE [G]) is -- Append a copy of s. -- (from SEQUENCE) require -- from SEQUENCE argument_not_void: s /= void local l: like s do if s = Current then l := deep_clone (s) else l := s end from l.start until l.exhausted loop extend (l.item) l.forth end ensure -- from SEQUENCE new_count: count >= old count end extend (v: G) is -- Add a new occurrence of v. -- (from BAG) require -- from COLLECTION extendible: extendible deferred ensure -- from COLLECTION item_inserted: is_inserted (v) ensure then -- from BAG one_more_occurrence: occurrences (v) = old (occurrences (v)) + 1 end fill (other: CONTAINER [G]) is -- Fill with as many items of other as possible. -- The representations of other and current structure -- need not be the same. -- (from COLLECTION) require -- from COLLECTION other_not_void: other /= void extendible local lin_rep: LINEAR [G] do lin_rep := other.linear_representation from lin_rep.start until not extendible or else lin_rep.off loop extend (lin_rep.item) lin_rep.forth end end force (v: like item) is -- Add v to end. -- (from SEQUENCE) require -- from SEQUENCE extendible: extendible do extend (v) ensure then -- from SEQUENCE new_count: count = old count + 1 item_inserted: has (v) end put (v: like item) is -- Replace current item by v. -- (Synonym for replace) -- (from CHAIN) require -- from COLLECTION extendible: extendible do replace (v) ensure -- from COLLECTION item_inserted: is_inserted (v) ensure then -- from CHAIN same_count: count = old count end put_i_th (v: like item; i: INTEGER) is -- Put v at i-th position. -- (from CHAIN) require -- from TABLE valid_key: valid_index (k) local pos: CURSOR do pos := cursor go_i_th (i) replace (v) go_to (pos) ensure then -- from INDEXABLE insertion_done: i_th (k) = v end replace (v: G) is -- Replace current item by v. -- (from ACTIVE) require -- from ACTIVE writable: writable deferred ensure -- from ACTIVE item_replaced: item = v end feature {NONE} -- Element change sequence_put (v: like item) is -- Add v to end. -- (from SEQUENCE) require -- from COLLECTION extendible: extendible do extend (v) ensure -- from COLLECTION item_inserted: is_inserted (v) ensure then -- from SEQUENCE new_count: count = old count + 1 end feature -- Removal prune (v: like item) is -- Remove the first occurrence of v if any. -- If no such occurrence go off. -- (from SEQUENCE) require -- from COLLECTION prunable: prunable do start search (v) if not exhausted then remove end end prune_all (v: like item) is -- Remove all occurrences of v; go off. -- (from SEQUENCE) require -- from COLLECTION prunable do from start until exhausted loop search (v) if not exhausted then remove end end ensure -- from COLLECTION no_more_occurrences: not has (v) end wipe_out is -- Remove all items. -- (from COLLECTION) require -- from COLLECTION prunable deferred ensure -- from COLLECTION wiped_out: is_empty end feature -- Transformation swap (i: INTEGER) is -- Exchange item at i-th position with item -- at cursor position. -- (from CHAIN) require -- from CHAIN not_off: not off valid_index: valid_index (i) local old_item, new_item: like item pos: CURSOR do pos := cursor old_item := item go_i_th (i) new_item := item replace (old_item) go_to (pos) replace (new_item) ensure -- from CHAIN swapped_to_item: item = old i_th (i) swapped_from_item: i_th (i) = old item end feature -- Conversion linear_representation: LINEAR [G] is -- Representation as a linear structure -- (from LINEAR) do Result := Current end feature -- Duplication duplicate (n: INTEGER): like Current is -- Copy of sub-chain beginning at current position -- and having min (n, from_here) items, -- where from_here is the number of items -- at or to the right of current position. -- (from CHAIN) require -- from CHAIN not_off_unless_after: off implies after valid_subchain: n >= 0 deferred end feature {NONE} -- Inapplicable bag_put (v: G) is -- (from TABLE) require -- from COLLECTION extendible: extendible do ensure -- from COLLECTION item_inserted: is_inserted (v) end remove is -- Remove current item. -- (from CHAIN) require -- from ACTIVE prunable: prunable writable: writable do end feature -- Iteration do_all (action: PROCEDURE [ANY, TUPLE [G]]) is -- 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 local t: TUPLE [G] do create t.make from start until after loop t.put (item, 1) action.call (t) forth end end do_if (action: PROCEDURE [ANY, TUPLE [G]]; test: FUNCTION [ANY, TUPLE [G], BOOLEAN]) is -- 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 local t: TUPLE [G] do create t.make from start until after loop t.put (item, 1) if test.item (t) then action.call (t) end forth end end for_all (test: FUNCTION [ANY, TUPLE [G], BOOLEAN]): BOOLEAN is -- Is test true for all items? -- (from LINEAR) require -- from TRAVERSABLE test_exits: test /= void local cs: CURSOR_STRUCTURE [G] c: CURSOR t: TUPLE [G] do create t.make cs ?= Current if cs /= void then c := cs.cursor end from start Result := True until after or not Result loop t.put (item, 1) Result := test.item (t) forth end if cs /= void then cs.go_to (c) end end there_exists (test: FUNCTION [ANY, TUPLE [G], BOOLEAN]): BOOLEAN is -- Is test true for at least one item? -- (from LINEAR) require -- from TRAVERSABLE test_exits: test /= void local cs: CURSOR_STRUCTURE [G] c: CURSOR t: TUPLE [G] do create t.make cs ?= Current if cs /= void then c := cs.cursor end from start until after or Result loop t.put (item, 1) Result := test.item (t) forth end if cs /= void then cs.go_to (c) end end invariant before_definition: before = (index = 0) after_definition: after = (index = count + 1) -- from ANY reflexive_equality: standard_is_equal (Current) reflexive_conformance: conforms_to (Current) -- 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 INDEXABLE index_set_not_void: index_set /= void -- 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 FINITE empty_definition: is_empty = (count = 0) non_negative_count: count >= 0 indexing library: "[ EiffelBase: Library of reusable components for Eiffel. ]" status: "[ Copyright 1986-2001 Interactive Software Engineering (ISE). For ISE customers the original versions are an ISE product covered by the ISE Eiffel license and support agreements. ]" license: "[ EiffelBase may now be used by anyone as FREE SOFTWARE to develop any product, public-domain or commercial, without payment to ISE, under the terms of the ISE Free Eiffel Library License (IFELL) at http://eiffel.com/products/base/license.html. ]" source: "[ Interactive Software Engineering Inc. ISE Building 360 Storke Road, Goleta, CA 93117 USA Telephone 805-685-1006, Fax 805-685-6869 Electronic mail <info@eiffel.com> Customer support http://support.eiffel.com ]" info: "[ For latest info see award-winning pages: http://eiffel.com ]" end -- class LIST
Classes Clusters Cluster hierarchy Chart Relations Text Flat Contracts Flat contracts Go to:

-- Generated by ISE Eiffel --
For more details: www.eiffel.com