Re: stream_element array contiguity

["Robert I. Eachus" <rieachus@attbi.com>]

Ian Leroux wrote:
> From reading previous posts, I gather that a common approach to
> dealing with bitwise input is to use Unchecked_Conversion to transform
> to packed arrays of Boolean from arrays of Stream_Element, obtained
> from an appropriate Stream package. Given that Stream_Element'Size is
> not guaranteed to be a multiple or factor of Storage_Element'Size, is
> there any way of being sure that the elements of a Stream_Element
> array will be contiguous? If not, is there any standard way of
> avoiding the problem whereby padding bits in the Stream_Element array
> corrupt the resulting boolean array?
> 
> I realize that on most compilers and platforms this is unlikely to be
> a real issue, but I'm wondering if there is any way to be sure (since
> being sure about this sort of thing is one of the features I find
> appealing about Ada).
> 
> I am a newcomer to the language, and would be glad to be called on any
> factual errors in this post.

It would be possible to write Ada code to correctly deal with this case, 
and not all that difficult.  But the code would invovle assigning bit 
slices, and the efficiency of that code would be compiler dependent.

In most areas I would tell you to trust the optimizer, but in this case 
I would probably write:

pragma Assert(Storage_Element'Size mod Stream_Element'Size = 0);

or whatever the actual assumption in your code is, even

paragma Assert(Storage_Element'Size = Stream_Element'Size);

I really don't think I'd like to try to get the code right for the more 
general case unless I had an implementation that I could correctly test 
the code on.