From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,INVALID_MSGID
	autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,f7611d1b6f46896b,start
X-Google-Attributes: gid103376,public
From: nospam.andrew.logue@cdcgy.com (Andrew Logue)
Subject: Byte-level to Bit-level Boolean Encoding
Date: 2000/03/31
Message-ID: <8F07A24FDandrewloguecdcgycom@142.77.1.194>#1/1
X-Deja-AN: 604559442
X-Trace: nnrp1.uunet.ca 954460884 209.167.52.146 (Thu,
 30 Mar 2000 19:01:24 EST)
Organization: Computing Devices Canada
User-Agent: Xnews/2.11.08
NNTP-Posting-Date: Thu, 30 Mar 2000 19:01:24 EST
Newsgroups: comp.lang.ada
Date: 2000-03-31T00:00:00+00:00
List-Id: <comp.lang.ada>


Hi, I have an interesting Ada problem which I need help with.
(I'm an Ada newbie)

I have an enumeration of "roles" say 

type role_kind is (a,b,c,d);

and then an array of booleans:

type role_selector_type is array (role_kind) of boolean;

this array of booleans is a series of switches which decides whether
the corresponding role is turned on or off.  (you can think of it as
a 2-dimensional array as well)

I have a variable:
 
Valid_Roles : role_selector_type;

which we will assume is populated with the correct values.

Now I need to transport Valid_Roles across a network.  My protocol 
definition specifies that the role selection is to be encoded into a 
single unsigned 32 bit integer, with each bit position corresponding to the
ordinal position of its role in role_kind, and its bit value indicating 
whether it is turned on or off.

How do I map the array of booleans into corresponding bits in a 32 bit 
integer?

I did this and now I'm stuck:

    type Role_Representation_Type is 
    record
      Role_0 : Boolean := False;
      Role_1 : Boolean := False;
      Role_2 : Boolean := False;
      Role_3 : Boolean := False;
      Role_4 : Boolean := False;
      Role_5 : Boolean := False;
      Role_6 : Boolean := False;
      Role_7 : Boolean := False;
      Role_8 : Boolean := False;
      Role_9 : Boolean := False;
      Role_10 : Boolean := False;
      Role_11 : Boolean := False;
      Role_12 : Boolean := False;
      Role_13 : Boolean := False;
      Role_14 : Boolean := False;
      Role_15 : Boolean := False;
      Role_16 : Boolean := False;
      Role_17 : Boolean := False;
      Role_18 : Boolean := False;
      Role_19 : Boolean := False;
      Role_20 : Boolean := False;
      Role_21 : Boolean := False;
      Role_22 : Boolean := False;
      Role_23 : Boolean := False;
      Role_24 : Boolean := False;
      Role_25 : Boolean := False;
      Role_26 : Boolean := False;
      Role_27 : Boolean := False;
      Role_28 : Boolean := False;
      Role_29 : Boolean := False;
      Role_30 : Boolean := False;
      Role_31 : Boolean := False;
    end record;

    -- force the series of booleans to be represented as a series of bits 
    -- (0..31)  type Boolean is an enumerated type.  will this work? 
    --
    for Role_Representation_Type use
    record at mod 1
      Role_0 at 0 range 0..0;
      Role_1 at 0 range 1..1;
      Role_2 at 0 range 2..2;
      Role_3 at 0 range 3..3;
      Role_4 at 0 range 4..4;
      Role_5 at 0 range 5..5;
      Role_6 at 0 range 6..6;
      Role_7 at 0 range 7..7;
      Role_8 at 0 range 8..8;
      Role_9 at 0 range 9..9;
      Role_10 at 0 range 10..10;
      Role_11 at 0 range 11..11;
      Role_12 at 0 range 12..12;
      Role_13 at 0 range 13..13;
      Role_14 at 0 range 14..14;
      Role_15 at 0 range 15..15;
      Role_16 at 0 range 16..16;
      Role_17 at 0 range 17..17;
      Role_18 at 0 range 18..18;
      Role_19 at 0 range 19..19;
      Role_20 at 0 range 20..20;
      Role_21 at 0 range 21..21;
      Role_22 at 0 range 22..22;
      Role_23 at 0 range 23..23;
      Role_24 at 0 range 24..24;
      Role_25 at 0 range 25..25;
      Role_26 at 0 range 26..26;
      Role_27 at 0 range 27..27;
      Role_28 at 0 range 28..28;
      Role_29 at 0 range 29..29;
      Role_30 at 0 range 30..30;
      Role_31 at 0 range 31..31;
    end record;    

    for Role_Representation_Type'Size use Basic_Types.Bits * 32;


If I declare this record variable:

   Roles_at_bit_level : Role_Representation_Type;

and populate it with Valid_Roles, then I think I can do this, but I'm not 
sure:

 variable_to_transport : Basic_Types.Unsigned_Integer32_Type;

for variable_to_transport use at Roles_at_bit_level'Address;


This should give me my 32 bit integer with the appropriate bits set.  Now I 
can just encode this integer into my bytestream and transmit it normally.

Am I on the right track here?  Is there a better way to do it with an array 
of booleans in the Role_Representation_Type record instead of 32 
distinctly-named members?

I'm using Ada '83 in case that's important.

Thanks for any help or ideas,
Andrew.