Re: Stream_Element_Array

[Alexander Korolev <antonovkablog@gmail.com>]

On Sep 16, 12:48 am, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:
> On Thu, 15 Sep 2011 11:58:21 -0700 (PDT), Alexander Korolev wrote:
> > On Sep 15, 12:20 pm, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> > wrote:
> >> On Wed, 14 Sep 2011 14:29:41 -0700 (PDT), Alexander Korolev wrote:
> >>> "In your case the other end is not the memory but the wire"
> >>> I am not sure I undestand you complitly. What's wrong, at least for
> >>> now, to build \ construct in memory the Buffer (Stream_Element_Array)
> >>> with full command (according the format I posted) inside and after
> >>> that send it over any stream (including GNAT.Serial, Socket etc)
> >>> derived from Root_Stream_Type. Basicly, I don't need even a Type -
> >>> I am using it just get Unsigned_16 serialized into Stream Elements.
>
> >> Yes, but in most cases it does not work so straightforwardly. You usually
> >> need headers, checksums etc. The point is that you have more layers of the
> >> protocol than just raw values over stream of octets. This is why you use
> >> stream rather as a transport for packets/messages and often more upper
> >> levels too (state machine etc). The idea is to always encapsulate each
> >> level into a data type. It saves much time later.
>
> >>> That's it. It's kind of hadcrafting. I also can override My_Type'Write
> >>> attribute and send to Serial port ... Your approach is to create a new
> >>> stream actully, which will take into account the PROTOCOL specifics.
> >>> Absolutly agree with that. But what is wrong with manual approach I am
> >>> implementing.
>
> >> It is not wrong, it is just might not work because protocols are more
> >> complex (layered) than this simple model.
>
> > 1. Can not disagree again - layers, state machines is "must" part.
> > 2. So far got some interim results with serialization of the Type
> >    in Volatile Stream. The Last set to 3? It looks I am getting
> >    there but no confidence so far.
>
> Volatile Stream has a bug in its implementation. Last is actually "Next".
>
> Anyway, here is how I do such stuff:
>
>    with Volatile_Streams;  use Volatile_Streams;
>    with Ada.Streams;       use Ada.Streams;
>    with Interfaces;        use Interfaces;
>
>    package Frame_Streams is
>       Protocol_Error : exception;
>       --
>       -- Implements frame I/O layer over the stream transport.
>       -- In this case the transport is memory-resident stream.
>       --
>       type Frame_Stream (Size : Stream_Element_Count) is
>          tagged limited private;
>          -- Send frame, Data is the frame body
>       procedure Send
>                 (  Stream : in out Frame_Stream;
>                    Data   : Stream_Element_Array
>                 );
>          -- Receive frame, Data is the frame body, Last its last item
>          -- Protocol_Error is propagated upon protocol errors
>       procedure Receive
>                 (  Stream : in out Frame_Stream;
>                    Data   : out Stream_Element_Array;
>                    Last   : out Stream_Element_Offset
>                 );
>    private
>       Max_Frame_Size : constant := 256;
>       type Frame_Stream  (Size : Stream_Element_Count) is
>          new Memory_Resident_Stream (Size) with
>       record
>          Output : Stream_Element_Array (1..Max_Frame_Size);
>       end record;
>    end Frame_Streams;
>
>    package body Frame_Streams is
>       procedure Send
>                 (  Stream : in out Frame_Stream;
>                    Data   : Stream_Element_Array
>                 )  is
>          Sum : Unsigned_8 := 0;
>       begin
>          if Data'Length + 4 > Stream.Output'Length then
>             raise Constraint_Error with "Packet is too large";
>          end if;
>          Stream.Output (1) := 0;
>          Stream.Output (2) := Stream_Element'Val (Data'Length / 256);
>          Stream.Output (3) := Stream_Element'Val (Data'Length mod 256);
>          Stream.Output (4..3 + Data'Length) := Data;
>          for Index in Stream_Element_Offset
>              range 2..3 + Data'Length
>          loop
>             Sum := Sum + Stream_Element'Pos (Stream.Output (Index));
>          end loop;
>          Stream.Output (4 + Data'Length) := Stream_Element'Val (Sum);
>          Stream.Write (Stream.Output (1..4 + Data'Length));
>       end Send;
>
>       procedure Receive
>                 (  Stream : in out Frame_Stream;
>                    Data   : out Stream_Element_Array;
>                    Last   : out Stream_Element_Offset
>                 )  is
>          Length : Stream_Element_Offset;
>          Sum    : Unsigned_8;
>          Input  : Stream_Element_Array (1..2);
>       begin
>          Stream.Read (Input (1..1), Last);
>          if Last /= 2 then
>             raise Protocol_Error with "Frame header expected";
>          elsif Input (1) /= 0 then
>             raise Protocol_Error with "Wrong leading byte";
>          end if;
>          Stream.Read (Input (1..2), Last);
>          Length := Stream_Element'Pos (Input (1)) * 256
>                  + Stream_Element'Pos (Input (2));
>          if Last /= 3 then
>             raise Protocol_Error with "Unexpected end of stream";            
>          elsif Length > Data'Length then
>             raise Protocol_Error with "Frame is too large";
>          end if;
>          Sum := Stream_Element'Pos (Input (1))
>               + Stream_Element'Pos (Input (2));
>          Stream.Read (Data (Data'First..Data'First + Length - 1), Last);
>          if Last /= Data'First + Length then
>             raise Protocol_Error with "Unexpected end of stream";
>          end if;
>          Stream.Read (Input (1..1), Last);
>          if Last /= 2 then
>             raise Protocol_Error with "Unexpected end of stream";
>          end if;
>          Last := Data'First + Length - 1;
>          for Index in Data'First..Last loop
>             Sum := Sum + Stream_Element'Pos (Data (Index));
>          end loop;
>          if Sum /= Stream_Element'Pos (Input (1)) then
>             raise Protocol_Error with "Checksum error";
>          end if;
>       end Receive;
>    end Frame_Streams;
>
> To be used as follows:
>
>    with Ada.Text_IO;     use Ada.Text_IO;
>    with Frame_Streams;  use Frame_Streams;
>
>    procedure Put (Data : Stream_Element_Array) is
>    begin
>       for Index in Data'Range loop
>          Put (Stream_Element'Image (Data (Index)));
>          Put (' ');
>       end loop;
>    end Put;
>
>    S : aliased Frame_Stream (1024);
>    Buffer : Stream_Element_Array (1..4);
>    Last   : Stream_Element_Offset;
> begin
>    S.Send ((1, 2, 3, 4));
>    Put_Line ("Written:" & Stream_Element_Count'Image (S.Extent));
>    S.Receive (Buffer, Last);
>    Put_Line ("Read:");
>    Put (Buffer (1..Last));
> end;
>
> Note that is in its turn is frame I/O layer. Upon it you will have another
> layer and so on up to the application layer.
>
> P.S. It is a bit simplified, if there are many transports layers, the frame
> layer would take the actual transport as a discriminant (access to
> Root_Stream'Class) or a generic parameter. In your case it would be an
> overkill.
>
> --
> Regards,
> Dmitry A. Kazakovhttp://www.dmitry-kazakov.de

Thanks. Will help.