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

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

Marin David Condic wrote:

> I'll see what I can do to trim down a small example and post it here.

Here's a relatively short example that will compile and run. It doesn't do anything
terribly useful, but you could use it as the basis for playing some games & learning
how it works. For example, you can throw some Text_IO into the code to see when the
Read and Write get called and with what values. You could add a big ring buffer to
the My_Stream_Type and have it store and retrieve values from there - sort of
simulating the existence of a Stream file. Or you could use Text_IO to simulate an
I/O device in some way. You might also try defining your own data type - some sort
of class (record, tagged record, etc.) and fool with overriding the Read and Write.
See what you get with the defaults and see how you might implement your own methods
of getting things into a byte stream.

This will begin to give you a feel for how it works and you'll understand some of
the issues relating to streams better. (Efficiency, representations, etc.) More
questions? Post them here and we'll see if answers come up.

with Ada.Streams ;


package My_Stream is

    type My_Stream_Type is new Ada.Streams.Root_Stream_Type with private ;

    type My_Stream_Ptr is access all Ada.Streams.Root_Stream_Type'Class ;

    --
    --  You need this to get a pointer to the My_Stream object. The
    --  pointer is used in calls such as:
    --  Some_Type'Read (My_Stream_Ptr, My_Object) ;
    --
    procedure Stream (
        My_Stream      : in out My_Stream_Type ;
        Ptr            :    out My_Stream_Ptr) ;

private

    procedure Read (
        Stream  : in out My_Stream_Type ;
        Item    :    out Ada.Streams.Stream_Element_Array ;
        Last    :    out Ada.Streams.Stream_Element_Offset) ;

    procedure Write (
        Stream  : in out My_Stream_Type ;
        Item    : in     Ada.Streams.Stream_Element_Array) ;

    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 ;
    --
end My_Stream ;

package body My_Stream is




    procedure Stream (
        My_Stream      : in out My_Stream_Type ;
        Ptr            :    out My_Stream_Ptr) is
        --
    begin
        Ptr    := My_Stream'Unchecked_Access ;
    end Stream ;



    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 ;



    procedure Write (
        Stream  : in out My_Stream_Type ;
        Item    : in     Ada.Streams.Stream_Element_Array) is
        --
        --  This is called automagically from the background as things
        --  are being converted by Something'Write.
        --
    begin
       --
       --  This is where you would do something to make the bytes in Item
       --  go out to some low level I/O port or other destination. Here
       --  we basically do nothing for this example.
       --
       for X in Item'Range loop
           null ;    -- Insert your "Write a byte to the I/O port" code here.
       end loop ;
    end Write ;



end My_Stream ;

with My_Stream ;
use My_Stream ;

procedure My_Stream_Driver is
    A_Stream    : My_Stream_Type ;
    A_Ptr       : My_Stream_Ptr ;
    --
    Some_Int    : Integer           := 15 ;
    Some_Float  : Float             := 10.5 ;
    Some_String : String (1..10)    := "XXXXXXXXXX" ;
begin
    Stream (
        My_Stream    => A_Stream,
        Ptr          => A_Ptr) ;
    --
    --  Finds its way to My_Stream.Write with (probably) a 4 byte
    --  Stream_Element_Array.
    --
    Integer'Write (A_Ptr, Some_Int) ;
    --
    --  Goes to My_Stream.Write with how many bytes?
    --
    Float'Write (A_Ptr, Some_Float) ;
    --
    --  This *should* go to My_Stream.Write with 10 bytes.
    --
    String'Write (A_Ptr, Some_String) ;
    --
    --  Read the values in - We get useless values unless
    --  we fill in the My_Stream.Read with something to
    --  get the values from somewhere.
    --
    String'Read (A_Ptr, Some_String) ;
    Float'Read (A_Ptr, Some_Float) ;
    Integer'Read (A_Ptr, Some_Int) ;
    --
end My_Stream_Driver ;
--
======================================================================
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
======================================================================