Skip to main content

A.9 The Generic Package Storage_IO

danger

This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue

1

The generic package Storage_IO provides for reading from and writing to an in-memory buffer. This generic package supports the construction of user-defined input-output packages.

1.a
reason
This package exists to allow the portable construction of user-defined direct-access-oriented input-output packages. The Write procedure writes a value of type Element_Type into a Storage_Array of size Buffer_Size, flattening out any implicit levels of indirection used in the representation of the type. The Read procedure reads a value of type Element_Type from the buffer, reconstructing any implicit levels of indirection used in the representation of the type. It also properly initializes any type tags that appear within the value, presuming that the buffer was written by a different program and that tag values for the“same” type might vary from one executable to another.

Static Semantics

2

The generic library package Storage_IO has the following declaration:

3/5
with Ada.IO_Exceptions;
with System.Storage_Elements;
generic
   type Element_Type is private;
package Ada.Storage_IO
   with Preelaborate, Global => in out synchronized is 
4Buffer_Size : constant System.Storage_Elements.Storage_Count :=
      implementation-defined;
   subtype Buffer_Type is
      System.Storage_Elements.Storage_Array(1..Buffer_Size);
5-- Input and output operations
6procedure Read (Buffer : in  Buffer_Type; Item : out Element_Type);
7procedure Write(Buffer : out Buffer_Type; Item : in  Element_Type);
8-- Exceptions
9Data_Error   : exception renames IO_Exceptions.Data_Error;
end Ada.Storage_IO;
10

In each instance, the constant Buffer_Size has a value that is the size (in storage elements) of the buffer required to represent the content of an object of subtype Element_Type, including any implicit levels of indirection used by the implementation. The Read and Write procedures of Storage_IO correspond to the Read and Write procedures of Direct_IO (see A.8.4), but with the content of the Item parameter being read from or written into the specified Buffer, rather than an external file.

10.a
reason
As with Direct_IO, the Element_Type formal of Storage_IO does not have an unknown_discriminant_part so that there is a well-defined upper bound on the size of the buffer needed to hold the content of an object of the formal subtype (i.e. Buffer_Size). If there are no implicit levels of indirection, Buffer_Size will typically equal:
10.b
(Element_Type'Size + System.Storage_Unit - 1) / System.Storage_Unit
10.c
implementation defined
The value of Buffer_Size in Storage_IO.
11
note
NOTE A buffer used for Storage_IO holds only one element at a time; an external file used for Direct_IO holds a sequence of elements.

Extensions to Ada 83

11.a/3
note
Storage_IO is new in Ada 95.