From mboxrd@z Thu Jan 1 00:00:00 1970 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00 autolearn=ham autolearn_force=no version=3.4.4 X-Google-Language: ENGLISH,ASCII-7-bit X-Google-Thread: 103376,842accb6a7d76669,start X-Google-Attributes: gid103376,public X-Google-ArrivalTime: 2001-11-02 12:43:59 PST Path: archiver1.google.com!news2.google.com!news1.google.com!sn-xit-02!supernews.com!newsfeed.direct.ca!look.ca!newshub2.rdc1.sfba.home.com!news.home.com!news1.denver1.co.home.com.POSTED!not-for-mail Message-ID: <3BE301D1.4010106@telepath.com> From: Ted Dennison User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:0.9.5) Gecko/20011011 X-Accept-Language: en-us MIME-Version: 1.0 Newsgroups: comp.lang.ada Subject: List container strawman 1.1 Content-Type: text/plain; charset=us-ascii; format=flowed Content-Transfer-Encoding: 7bit Date: Fri, 02 Nov 2001 20:29:47 GMT NNTP-Posting-Host: 24.10.28.160 X-Complaints-To: abuse@home.net X-Trace: news1.denver1.co.home.com 1004732987 24.10.28.160 (Fri, 02 Nov 2001 12:29:47 PST) NNTP-Posting-Date: Fri, 02 Nov 2001 12:29:47 PST Organization: Excite@Home - The Leader in Broadband http://home.com/faster Xref: archiver1.google.com comp.lang.ada:15695 Date: 2001-11-02T20:29:47+00:00 List-Id: I have a new version of the strawman up at my website at http://www.telepath.com/dennison/Ted/Containers-Lists-Unbounded.ads.html . This version has the cascading style sheet too, so hopefully nearly everyone should be able to read it. I tried to incorporate all of today's comments that don't require further discussion. If you made a comment that isn't incorporated, it either means that I think it need more discussion, or I forgot (sorry, it happens). If I missing something, please point it out. I'm going to make one more attempt to attach it as text and not HTML. It may look a bit ugly due to some lines being longer than 60 characters. with Ada.Finalization; with Ada.Streams; ------------------------------------------------------------------------------- -- This file contains a proposal for a standard Ada list package. -- -- version - Strawman 1.1 ------------------------------------------------------------------------------- generic type Element is private; package Containers.Lists.Unbounded is ----------------------------------------------------------------------------- -- The list type. I know the name's a bit redundant, but it doesn't look too -- bad, and any fully-named use will have to have a different name for the -- package anyway. ----------------------------------------------------------------------------- type List is private; ----------------------------------------------------------------------------- -- List construction operations. The returned list will contain *copies* of -- all the elements in the source lists, so these routines could get -- time-consuming. However, they should be useful for Lisp-like processing. -- -- I'm trying out using unary plus ("+") for the "Construct" routine, but -- that's not a common idiom right now. ----------------------------------------------------------------------------- function "&" (Left, Right : Element) return List; function "&" (Left : Element; Right : List) return List; function "&" (Left : List; Right : Element) return List; function "&" (Left, Right : List) return List; function "+" (Initial_Element : Element) return List; ----------------------------------------------------------------------------- -- "push" and "pop" operations. Pops on empty lists raise No_Item. ----------------------------------------------------------------------------- No_Item : exception; procedure Push_Front (Target : in out List; New_Element : in Element); procedure Pop_Front (Target : in out List; Old_Element : out Element); procedure Push_Back (Target : in out List; New_Element : in Element); procedure Pop_Back (Target : in out List; Old_Element : out Element); ----------------------------------------------------------------------------- -- Non-modifying query operations. ----------------------------------------------------------------------------- function Is_Empty (Subject : List) return Boolean; function Size (Subject : List) return Natural; function Front (Subject : List) return Element; function Back (Subject : List) return Element; ----------------------------------------------------------------------------- -- Passive iterator. Operation will be applied on each element on the list -- Opertion can terminate this process early by setting Quit to True. ----------------------------------------------------------------------------- generic with procedure Operation (Target : in out Element; Quit : out Boolean); procedure Passive_Iterator (Target : in out List); ----------------------------------------------------------------------------- -- Iteration routines. For an empty list, First = Done_Iterating. Item and -- Remove raise No_Item if they are called with a value of Done_Iterating. -- As written, a typical iteration idiom would look like: -- -- i := My_Lists.First (My_List); -- while i /= My_Lists.Done_Iterating loop -- do stuff with My_Lists.Item(i); -- i := My_Lists.Next (i); -- end loop; -- -- Another alternative using "Size" would be: -- -- i := My_Lists.First (My_List); -- for iteration_count in 1..My_Lists.Size (My_List) loop -- do stuff with My_Lists.Item (i); -- i := My_Lists.Next (i); -- end loop; -- ----------------------------------------------------------------------------- type Iterator is private; Done_Iterating : constant Iterator; function First (Subject : List) return Iterator; function Last (Subject : List) return Iterator; function Next (Location : Iterator) return Iterator; function Previous (Location : Iterator) return Iterator; function Item (Location : Iterator) return Element; -- Ideally these routines would verify that Location was issued for the Subject -- list and is still valid, but that would be tough to enforce. Better to call -- such misuse a "bounded error", or somesuch. ----------------------------------------------------------------------------- -- Remove the element at the given location, and advance Location to the next -- element. -- If Location=Done_Iterating then No_Item will be raised. -- If Location=First, then Location will be set to the new First. -- If Location=Last, then Location will be set to Done_Iterating. -- otherwise, Location will be set to what Next was previously (the next -- element after the removal). ----------------------------------------------------------------------------- procedure Remove (Subject : in out List; Location : in out Iterator); ----------------------------------------------------------------------------- -- Insert the given element at the given location in the list (in front of -- the element that is already there). Location will continue to point to the -- same element. -- If Location=Done_Iterating, then the element will be put at the end of the -- list. Otherwise, the element will be placed immediately before the element -- at Location. Location will continue to reference that element. ----------------------------------------------------------------------------- procedure Insert (Subject : in out List; Location : in Iterator; New_Item : in Element); ----------------------------------------------------------------------------- -- Sorting routine. -- To sort in increasing order, use the ">" routine for the Reverse_Order -- parameter. To sort in decreasing order, substitute your "<" routine for -- the Reverse_Order parameter. :-) ----------------------------------------------------------------------------- generic with function Reverse_Order (Left, Right : in Element) return Boolean; procedure Sort (Subject : in out List); ----------------------------------------------------------------------------- -- Stream attributes. ----------------------------------------------------------------------------- procedure Stream_Read (Stream : access Ada.Streams.Root_Stream_Type'Class; Item : out List); procedure Stream_Write (Stream : access Ada.Streams.Root_Stream_Type'Class; Item : in List); private -- Placebo entries to make the compiler happy (so I know the syntax above is correct) ----------------------------------------------------------------------------- -- Note that the list type is controlled. This makes this entire package -- unsusable anywhere but at the library level. The other option would be to remove -- the functions and make it limited. type List is new Ada.Finalization.Controlled with null record; for List'Read use Stream_Read; type Iterator is new Boolean; for List'Write use Stream_Write; Done_Iterating : constant Iterator := Iterator'First; end Containers.Lists.Unbounded;