Re: Streams in Ada

["David C. Hoos, Sr." <david.c.hoos.sr@ada95.com>]

Stream_Elements are the smallest addressable element of the medium
usually an octet (8 bits).

The Index (position) of a stream file can be read using the function
Ada.Streams.Stream_IO.Index, and the index can be set using the
procedure Ada.Streams.Stream_IO.Set_Index.

The first index of a file is 1.

Read and write operations are automatically declared for
every type you declare, so you can just call Superblock_type'Read,
Superblock_type'Write, etc. when the file index is appropriately
positioned.

The 'Read and "write procedures defined by the compiler follow
certain rules which may not be appropriate for some types you
could declare. For example, if a record has elements that do not
begin and end on byte boundaries, you can override the compiler-
defined procedures with your own.

Here is an example of such a type, where a 32-bit record has a
31-bit component, and a 1-bit component.

-- Part of package specification:
with Ada.Streams;
   .
   .
   .
   type An_Hour_Fraction is
     delta 3600.0 * 2.0 ** (-31) range 0.0 .. 3600.0;
   for An_Hour_Fraction'Small use 3600.0 * 2.0 ** (-31);
   for An_Hour_Fraction'Size use 31;
   type A_Time_Stamp_Kind is (Relative, Absolute);
   for A_Time_Stamp_Kind use (Relative => 0, Absolute => 1);
   for A_Time_Stamp_Kind'Size use 1;

   type A_Time_Stamp is
      record
         Seconds : An_Hour_Fraction;
         Kind : A_Time_Stamp_Kind;
      end record;
   for A_Time_Stamp use
      record
         Seconds at 0 range 0 .. 30;
         Kind at 0 range 31 .. 31;
      end record;
   for A_Time_Stamp'Size use 32;

private
   procedure Read_Time_Stamp
               (Stream : access Ada.Streams.Root_Stream_Type'Class;
                Item : out A_Time_Stamp);

   procedure Write_Time_Stamp
               (Stream : access Ada.Streams.Root_Stream_Type'Class;
                Item : in A_Time_Stamp);
   for A_Time_Stamp'Read use Read_Time_Stamp;
   for A_Time_Stamp'Write use Write_Time_Stamp;




-- Part of package body:
 with Ada.Unchecked_Conversion;
with Interfaces;
   .
   .
   .
   function To_Time_Stamp is new Ada.Unchecked_Conversion
     (Source => Interfaces.Unsigned_32,
      Target => A_Time_Stamp);

  function To_Unsigned_32 is new Ada.Unchecked_Conversion
     (Source => A_Time_Stamp,
      Target => Interfaces.Unsigned_32);

    procedure Read_Time_Stamp
     (Stream : access Ada.Streams.Root_Stream_Type'Class;
      Item : out A_Time_Stamp) is
   begin
     Item := To_Time_Stamp (Interfaces.Unsigned_32'Input (Stream));
  end Read_Time_Stamp;

    procedure Write_Time_Stamp
     (Stream : access Ada.Streams.Root_Stream_Type'Class;
      Item : in A_Time_Stamp) is
   begin
      Interfaces.Unsigned_32'Write
        (Stream,
         To_Unsigned_32 (Item));
   end Write_Time_Stamp;


"chris.danx" <chris.danx@ntlworld.com> wrote in message
news:XRrx6.7012$u93.987018@news6-win.server.ntlworld.com...
> Direct IO handles single type files, i.e. all file elements are the same.
I
> want different types in the file i.e. heterogeneous files.  Streams allow
> this so i need streams.
>
> I want to allow the reading and writing of 3 or 4 types.
>
>     type Superblock_type;
>     type Inode_type;
>     type Data_block_type;
>     type FileInfo_block_type;
>
> surely then i want streams.  I did think about direct io but i'd have
severe
> performance losses in the conversion to the smallest unit -- in this case
> byte_type;  Maybe i am looking in the wrong place.
>
> All i want is an example of how to access files using streams in a non
> sequential manner with one or two types.
>
> Cheers,
> Chris Campbell
>
>