Menu
▾
▴
Re: [Oorexx-devel] ooRexx 3.1 Beta 1 RPM
|
From: Rick M. <obj...@gm...> - 2006-05-11 21:39:42
|
I have a better suggestion, why not just add this to the base class set?
This looks generally useful enough. Please submit this as a patch, with th=
e
appropriate permission grant statement.
btw, just a small note on style, I noticed your of method had a direct
reference to the .circularQueue class variable. A better way of doing this
would be to use self~new() which decouples the class instance from the
actual assigned name.
Rick
On 5/11/06, Rony G. Flatscher <Ron...@wu...> wrote:
>
> Hi there,
>
> It might be possible to sneak them in. I am trying to get the official
> beta 1 out on Windows and Linux by the end of the month (May) and I am
> targeting the end of June for the actual release. Of course, if problems
> arrise that timeframe could go down the drain :-)
>
> a few days ago, I just "had it", because I needed a circular buffer again
> (as in the past one was needed from time to time)! So I sat down and came=
up
> with a very simple, yet rather powerful solution, which I enclose for
> feedback/comments. At the top of "circularQueue.rex" you'll see the
> documentation in ooRexx style.
>
> Maybe it makes also a nice contribution for the "utility set" for 3.1 ?
>
>
> I also think we are pretty close on having a working ooRexx for AIX. Mark
> is working on that.
>
> Great to hear!
>
> Regards,
>
> ---rony
>
>
> --- rgf, 2006-05-11, demo circularQueue
>
> r=3D.circularQueue~new(3)
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> say "--- --- ---"
>
> r~put("hallo")
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> call dump r
> say "--- --- ---"
>
> r~put("oha")
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> call dump r
> say "--- --- ---"
>
> r~put("joi!")
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> call dump r
> say "--- --- ---"
>
> r~put("nixi")
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> call dump r
> say "--- --- ---"
>
> r~put("sTi")
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> call dump r
> say "--- --- ---"
>
> r~put("wow")
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> call dump r
> say "--- --- ---"
>
> r~put("xxx")
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> call dump r
> say "--- --- ---"
>
> --------------------------------------------------------
> r=3D.circularQueue~new( 0)
>
> r~put("xxx")
> say pp(r) "items:" pp(r~items) "size:" pp(r~size)
> say pp(r~string("0d0a"x || "<hr>" || "0d0a"x))
> call dump r
> say "--- --- ---"
>
> --------------------------------------------------------
> u=3D.circularQueue~of("max", "und", .nil, "moritz")
> say pp(u) "items:" pp(u~items) "size:" pp(u~size)
> say "FIFO:" pp(u~string("0d0a"x || "<hr>" || "0d0a"x))
> say "now using a supplier:"
> call dump u
> say "now using 'do..over:' (FIFO):"
> do item over u
> say " " item
> end
> say "---"
> say "LIFO:" pp(u~string("0d0a"x || "<hr>" || "0d0a"x, .false))
> say "now using a supplier:"
> call dump u, .false
> say "now using 'makearray(.false)':"
> do item over u~makearray(.false)
> say " " item
> end
> say "--- --- ---"
>
> /*
> --------------------------------------------------------
> say "now producing intentional errors:"
> t=3D.circularQueue~new("max und moriz")
> t=3D.circularQueue~new(-1)
> */
> exit
>
> pp: procedure
> return "[" || arg(1) || "]"
>
>
> dump: procedure
> use arg o, fifo
> fifo=3D(fifo<>.false) -- default to FIFO
>
> s=3Do~supplier(fifo)
> do while s~available
> say " " pp(s~index) pp(s~item)
> s~next
> end
> return
>
> ::requires "circularQueue.rex"
>
>
> /*
> name: circularQueue.rex
> author: Rony G. Flatscher
> date: 2006-05-09, 2006-05-11
> purpose: allow to use a circular queue (buffer) of predefined size; if
> queue is full
> new entries overwrite existing ones in FIFO order (from the
> beginning)
>
> documentation:
>
> The CircularQueue class
> =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
>
> This is a collection class which allows for storing objects in a
> circular buffer
> of a predefined size. Once the end of the buffer has been reached,
> new objects
> are inserted from the beginning, replacing earlier entries.
>
> The collected objects can be processed in FIFO (first in, first out)
> or in a
> stack-like LIFO (last in, first out) order.
>
>
>
> OF (Class Method)
> =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
>
> +-,----+
> v |
> >>-OF(---item-+-)--------------------------<<
>
> Returns a newly created circular queue containing the specified item
> objects
> in the order specified. The number of listed items determines the size
> of the circular queue.
>
> INIT
> =3D=3D=3D=3D
>
> >>-INIT(size)----------------------------------<<
>
> Constructor method invoked by the NEW method, which determines the size
> of
> the circular queue.
>
>
> ITEMS
> =3D=3D=3D=3D=3D
>
> >>-ITEMS---------------------------------------<<
>
> Returns the number of items in the circular queue.
>
>
> MAKEARRAY
> =3D=3D=3D=3D=3D=3D=3D=3D=3D
> +-.true-+
> >>-MAKEARRAY(-+-------+-)----------------------<<
> +-bFIFO-+
>
> Returns a single-index array containing the items in FIFO (first-in,
> first-out)
> order, if bFIFO is set to .true or is omitted. If bFIFO is set to .fals=
e
> then
> the items are placed in the stacklike LIFO (last-in, first-out) order
> into the
> single-index array.
>
>
> PUT
> =3D=3D=3D
>
> >>-PUT(item)-----------------------------------<<
>
> Makes the object item a member item of the circular queue. If the
> circular
> queue is full, than the item replaces a previously stored object in
> (FIFO)
> circular order.
>
>
> SIZE
> =3D=3D=3D=3D=3D
>
> >>-SIZE----------------------------------------<<
>
> Returns the maximum number of objects that can be stored in the circula=
r
> queue.
>
>
> SUPPLIER
> =3D=3D=3D=3D=3D=3D=3D=3D=3D
> +-.true-+
> >>-SUPPLIER(-+-------+-)-----------------------<<
> +-bFIFO-+
>
> Returns a supplier object for the collection. After you have obtained a
> supplier,
> you can send it messages (see The Supplier Class) to enumerate all the
> items
> that wer in the circular queue at the time of the supplier's creation.
> The supplier enumerates the items in their queueing (FIFO: first-in,
> first-out)
> order. If you supplied bFIFO with a value of .false, then the supplier
> enumerates
> the items in the stack-like LIFO (last-in, first out) order.
>
> STRING
> =3D=3D=3D=3D=3D=3D
> +-----","----+ +---.true-+
> >>-STRING(-+------------+--+---------+-)--------<<
> +-delimitier-+ +-,-bFIFO-+
>
> Returns a string object that concatenates the string values of the
> collected
> items in FIFO (FIFO: first-in, first-out) order, using the delimiter
> string to
> delimit them. If the delimiter argument is omitted the comma character
> is used
> as the default string. If you supplied bFIFO with a value of .false,
> then the
> supplier enumerates the items in the stack-like LIFO (last-in, first
> out) order.
>
> */
>
>
>
> ::class circularQueue public -- circular buffer (round-robin queue) of
> predefined size
>
> ::method init -- create an instance, determines the
> capacigy once and forever
> expose size storage index items
> parse arg size
> index=3D0 -- indicate no entries as of yet
> items=3D0 -- indicate no entries as of yet
>
> signal on any
> storage=3D.array~new(size)
> exit
>
> any:
> raise propagate
>
> ::method items -- return actual number of entries (items)
> expose items
> return items
>
> ::method size -- return size
> expose size
> return size
>
>
> ::method put -- put an element into the queue, possibly
> replacing an existing one
> expose size storage index items
> use arg value
>
> if items<size then -- increase items
> items=3Ditems+1
>
> index=3Dindex+1 -- increase index
> if index>items then index=3D1 -- roll over
> storage[index]=3Dvalue -- save item
>
>
>
> ::method makearray -- return a supplier object
> expose size storage index items
> parse arg FIFO
>
> FIFO=3D(FIFO<>.false) -- default to FIFO
> valArr=3D.array~new(items)
>
> if FIFO=3D.true then -- FIFO: first in, first out
> do
> idx=3Dindex+1
> if idx>items then idx=3D1
>
> do i=3D1 to items -- iterate over
> valArr[i]=3Dstorage[idx] -- save value
> idx=3Didx+1
> if idx>size then idx=3D1 -- roll-over?
> end
> end
> else -- reverse direction, ie. LIFO (=3D stacklike): last in, first out
> do
> idx=3Dindex
> if idx>items then idx=3D1
>
> do i=3D1 to items -- iterate over
> valArr[i]=3Dstorage[idx] -- save value
> idx=3Didx-1
> if idx<1 then idx=3Ditems -- roll-over?
> end
> end
>
> return valArr
>
>
> ::method supplier -- return a supplier object
> expose size storage index items
> parse arg FIFO
>
> FIFO=3D(FIFO<>.false) -- default to FIFO
> idxArr=3D.array~new(items)
> valArr=3D.array~new(items)
>
> if FIFO=3D.true then -- FIFO: first in, first out
> do
> idx=3Dindex+1
> if idx>items then idx=3D1
>
> do i=3D1 to items -- iterate over
> idxArr[i]=3Didx -- save index
> valArr[i]=3Dstorage[idx] -- save value
> idx=3Didx+1
> if idx>size then idx=3D1 -- roll-over?
> end
> end
> else -- reverse direction, ie. LIFO (=3D stacklike): last in, first out
> do
> idx=3Dindex
> if idx>items then idx=3D1
>
> do i=3D1 to items -- iterate over
> idxArr[i]=3Didx -- save index
> valArr[i]=3Dstorage[idx] -- save value
> idx=3Didx-1
> if idx<1 then idx=3Ditems -- roll-over?
> end
> end
>
> return .supplier~new(valArr, idxArr)
>
>
>
> ::method string -- create a string representation, using th=
e
> optional delimiter
> expose size storage index items
> parse arg delimiter, FIFO
>
> FIFO=3D(FIFO<>.false) -- default to FIFO
> if arg(1,"Omitted") then -- default to comma as a separator, if
> argument was omitted
> delimiter=3D","
>
> mb=3D.MutableBuffer~new -- use a MutableBuffer for the string chun=
ks
>
> if FIFO=3D.true then -- FIFO: first in, first out
> do
> idx=3Dindex+1
> if idx>items then idx=3D1
>
> do i=3D1 to items -- iterate over
> if i>1 then -- add delimiter?
> mb~append(delimiter)
>
> mb~append(storage[idx]~string) -- create string value
> idx=3Didx+1
> if idx>size then idx=3D1 -- roll-over?
> end
> end
> else -- reverse direction, ie. LIFO (=3D stacklike): last in, first out
> do
> idx=3Dindex
>
> do i=3D1 to items -- iterate over
> if i>1 then -- add delimiter?
> mb~append(delimiter)
>
> mb~append(storage[idx]~string) -- create string value
> idx=3Didx-1
> if idx<1 then idx=3Ditems -- roll-over?
> end
> end
> return mb~string -- return string
>
>
>
> ::method of class
> storage=3D.circularQueue~new(arg())-- create an array of appropriate siz=
e
>
> do i=3D1 to arg()
> storage~put(arg(i)) -- now place values into circularQueue
> end
> return storage -- return instance
>
>
>
>
>
|