Re: Looping over a tagged record?

[B_Gaffney@My-Deja.com (B.Gaffney)]

An alternative to 'read and 'write (since in another post you relate
this to tagged types), is to use 'input and 'output.  This came up in
a thread about a month ago.

T'Output first writes the tag, then calls T'Write.  T'Input reads the
tag, determines the appropriate type, then calls the proper T'Read.

The problem I've found, at least with GNAT, is that 'Input/'Output use
the "external representation" of the tag, which for GNAT is the fully
qualified text name of the type (talk about long filenames -- unless
you're careful).  So, unless you have rather large objects or don't
care about storage efficiency, this method has significant overhead.


Charles Hixson <charleshixson@earthling.net> wrote in message news:<Xns90C7A319CCC90charleshixsonearthli@207.217.77.21>...
> tmoran@acm.org wrote in
> news:ltrY6.111132$%i7.79731461@news1.rdc1.sfba.home.com: 
> 
> >> basically need to do is examine the incoming data and
> >...
> >  Look at packages Ada.Streams and Ada.Stream_IO
> > Stream_IO lets you read an arbitrary number of bytes into a
> > Stream_Element_Array, and Streams lets you conveniently
> > convert those raw bytes into an object of type whatever.
> >   Suppose your data stream has a series of objects.  Each
> >   object 
> > is preceded by a single character identifying code.  Then
> > you could 
> >   Character'Read((Stream, ID_Code);
> >   case ID_Code is
> >     when 'A' => An_Object_Type'Read(Stream, An_Object);
> >     when 'B' => A_Different_Type'Read(Stream,
> >     A_Different_Object); ...
> > If An_Object_Type is a record, Ada will automatically read
> > it by a series of 'Read, of the correct type, on each
> > component - or you could override that and instead supply
> > your own 'Read. 
> > 
> That looks quite interesting.  I would definitely need to supply 
> my own read, and probably my own write too, since the objects 
> will likely need to be stored in non-contiguous areas of the 
> file. (If freed space can't be reused, the process would be 
> unacceptably inefficient.  And when dealing with small chunks of 
> data I would also need to be able to pack then into blocks.)
> 
> If I can make that work it will certainly be better than the 
> alternatives that had occurred to me. (Address mapped storage, 
> e.g., with arbitrary mappings needing to be defined.  Ugh!  Or 
> tagged types, with all of the basic types defined for every 
> possible offset into the block.  Ugh! again.)
> 
>  ...
> After looking at the package:  Perhaps I need to rethink things 
> to use arbitrary sized blocks rather than fixed size blocks.  
> Otherwise it looks like just what I was looking for!
> 
> 
> -- 
> Charles Hixson
> 
> Copy software legally, the GNU way!
> Use GNU software, and legally make and share copies of software.
> See http://www.gnu.org
>     http://www.redhat.com
>     http://www.linux-mandrake.com
>     http://www.calderasystems.com/
>     http://www.linuxapps.com/