Re: Ada Streams usage (was Escape Sequences in Strings)

[Marin David Condic <mcondic.nospam@acm.org>]

Brian Orpin wrote:

> >    type My_Stream_Type is new Ada.Streams.Root_Stream_Type with record
> >        --
> >        --  This is where you would retain information about I/O buffers,
> >        --  I/O ports, etc. so that Read and Write can know where to
> >        --  retreive or send their data. A simple case might be a big ring
> >        --  buffer with Write attaching to the end and Read pulling stuff
> >        --  off from the beginning. Not really useful, but it makes the
> >        --  point.
> >        --
> >        null ;
> >    end record ;
>
> Can't see how information on the IO buffers goes in here.
>

Suppose for example that you are supporting a MilStd1553 communications device.
Or maybe several of them. There's going to be information here about addresses &
subaddresses which you would store in here via some kind of "Initialize"
procedure that is visible from the spec. The 1553 is likely to have one or more
memory mapped buffers from which it reads a chunk of data and spews it down the
wire. Your code needs to know where those buffers are and probably has to
maintain info about which is the next one to be filling, etc. So you would store
the memory addresses here.

Or you might have an application that uses some other hardware or protocol where
you don't want to send every little byte that comes along, but want to save them
up into some bigger chunk. Declare a local buffer (a Stream_Element_Array) of
some sufficient size along with indexes to know where you left off filling it.
When it gets full, you do the sending of the data at that point.

It depends on your application, but that's generally the way I would use the
Root_Stream_Type for a communication application. I've found other uses for it as
well - it can be used as a means of converting data of some type (tagged records
in particular) into a Stream_Element_Array using the Root_Stream_Type as an
intermediary storage location.

Use your imagination and you may come up with more...


>
> >    procedure Read (
> >        Stream  : in out My_Stream_Type ;
> >        Item    :    out Ada.Streams.Stream_Element_Array ;
> >        Last    :    out Ada.Streams.Stream_Element_Offset) is
> >        --
> >        --  This is called automagically from the background as things
> >        --  are being converted by Something'Read.
> >        --
> >    begin
> >        --
> >        --  Normally, you'd do something to access a low-level I/O
> >        --  device or use some other means to get hold of raw bytes
> >        --  from some source at this point in the code. Here we
> >        --  just fill it with zeros as a not too useful example.
> >        --
> >        for X in Item'Range loop
> >            Item (X) := 0 ;
> >        end loop ;
> >        Last    := Item'Last ;
> >    end Read ;
>
> It is the bit about getting the raw bytes that interested me.  I was
> hoping that Streams did a bit more but obviously not.
>

What did you think they should do? Were you under the impression that Streams
could be informed of the source of some raw bytes and that they would connect up
to it with little or no code provided by the programmer? I'm not clear about what
you are saying here.

>
> I just can't believe that someone hasn't done this and made it available.
> It is such a common problem.  Ho Hum I suppose I will need to find the
> time to do it.

Done what and made it available? I'm lost here.

MDC
--
======================================================================
Marin David Condic - Quadrus Corporation - http://www.quadruscorp.com/
Send Replies To: m c o n d i c @ q u a d r u s c o r p . c o m
Visit my web site at:  http://www.mcondic.com/

    "Giving money and power to Government is like giving whiskey
    and car keys to teenage boys."

        --   P. J. O'Rourke
======================================================================