Discriminant within discriminants

Discriminant within discriminants

[stuart clark]

I have a the following

package message_types

  type id_type is range 1..8;

 type dispense_ack (size:id_type:=id_Type'first) is
   record
     dispense_acks:array(1..size) of acks;
   end record;

  type message_types(dispense_acknowledgement, dispense_request);

  type in_messages(kind :msg_types:=msg_types'first) is
   record
    case type is
      when dispense_acknowledgement =>
         acknowledgements:dispense_ack;
      when dispense_request
         request:integer;
    end case
  end record;

end message_types;

i want to declare a message that is of dispense_acknowledgment type
with a size of 8

i can do

msg:message_types.in_messages(kind=>message_types.dispense_acknowledgment);

this gives me the correct message type but as the dispense_ack is
defaulted to size=1
i get a message of size 1.

the only way i can get my code to compile with a message size of 8 is
to use

declare
  msg:message_types.in_messages;
  dispense_ack_msg:message_types.dispense_ack(size=>8);
begin
  msg:=(kind=>message_types.dispense_acknowledgement,
            acknowledgements=>dispense_ack_msg);

end;

QUESTION : can i declare a message with a type and size in the one
statement without using the intermediate message.

Re: Discriminant within discriminants

[Jeffrey R. Carter]

stuart clark wrote:
> 
> package message_types
> 
>   type id_type is range 1..8;
> 
>  type dispense_ack (size:id_type:=id_Type'first) is
>    record
>      dispense_acks:array(1..size) of acks;
>    end record;
> 
>   type message_types(dispense_acknowledgement, dispense_request);

Do you want an "is" in there before the '('?

>   type in_messages(kind :msg_types:=msg_types'first) is
>    record
>     case type is
>       when dispense_acknowledgement =>
>          acknowledgements:dispense_ack;
>       when dispense_request
>          request:integer;
>     end case
>   end record;
> 
> end message_types;
> 
> i want to declare a message that is of dispense_acknowledgment type
> with a size of 8
> 
> the only way i can get my code to compile with a message size of 8 is
> to use
> 
> declare
>   msg:message_types.in_messages;
>   dispense_ack_msg:message_types.dispense_ack(size=>8);
> begin
>   msg:=(kind=>message_types.dispense_acknowledgement,
>             acknowledgements=>dispense_ack_msg);
> 
> end;
> 
> QUESTION : can i declare a message with a type and size in the one
> statement without using the intermediate message.

Msg : Message_Types.In_Messages :=
    (Kind => Message_Types.Dispense_Acknowledgement,
     Acknowledgements =>
        (Size => 8, Dispense_Acks => (1 .. 8 => Thing) ) );

This requires that a value of the (undefined) type Acks be available 
(Thing in the example).

If you don't have such a value, then something along the lines of your 
example is required. Note that you can also do

declare
    Msg : Message_Types.In_Messages
          (Kind => Message_Types.Dispense_Acknowledgement);
    DAM : Message_Types.Dispense_Ack (Size => 8);
begin
    Msg.Acknowledgements := DAM;
end;

(Note also that most dictionaries recommend the spelling "acknowledgment".)

-- 
Jeff Carter
"I would never want to belong to any club that
would have someone like me for a member."
Annie Hall
41

Re: Discriminant within discriminants

[Randy Brukardt]

"Jeffrey R. Carter" <spam.not.jrcarter@acm.not.spam.org> wrote in message
news:M656g.929814$x96.584697@attbi_s72...
...
> > QUESTION : can i declare a message with a type and size in the one
> > statement without using the intermediate message.
>
> Msg : Message_Types.In_Messages :=
>     (Kind => Message_Types.Dispense_Acknowledgement,
>      Acknowledgements =>
>         (Size => 8, Dispense_Acks => (1 .. 8 => Thing) ) );
>
> This requires that a value of the (undefined) type Acks be available
> (Thing in the example).

If you have Ada 2005 support, you can use the default initialization value
to avoid the need to specify a particular value:

Msg : Message_Types.In_Messages :=
     (Kind => Message_Types.Dispense_Acknowledgement,
      Acknowledgements =>
         (Size => 8, Dispense_Acks => (1 .. 8 => <>) ) );

                  Randy.

Re: Discriminant within discriminants

[stuart clark]

I tried exactly as you have both suggested but i get a gnat compile
error of

"Acknowledgements does not match any discriminant"

Re: Discriminant within discriminants

[Jeffrey R. Carter]

Randy Brukardt wrote:
> 
> If you have Ada 2005 support, you can use the default initialization value
> to avoid the need to specify a particular value:
> 
> Msg : Message_Types.In_Messages :=
>      (Kind => Message_Types.Dispense_Acknowledgement,
>       Acknowledgements =>
>          (Size => 8, Dispense_Acks => (1 .. 8 => <>) ) );

Yes, and when Ada 0X is standardized and compilers are available, that's 
the kind of advice I will give.

-- 
Jeff Carter
"I would never want to belong to any club that
would have someone like me for a member."
Annie Hall
41

Re: Discriminant within discriminants

[Jeffrey R. Carter]

stuart clark wrote:
> I tried exactly as you have both suggested but i get a gnat compile
> error of
> 
> "Acknowledgements does not match any discriminant"

Interesting. After correcting some obvious errors, I get

message_test.adb:7:26: anonymous arrays not allowed as components

Correcting that, I get

message_test.adb:25:04: warning: variable "Msg" is not referenced

The code is

procedure Message_Test is
    package Message_Types is
       type Id_Type is range 1 .. 8;

       type Acks is new Boolean;

       type Ack_List is array (Id_Type range <>) of Acks;

       type Dispense_Ack (Size : Id_Type := Id_Type'First) is record
          Dispense_Acks : Ack_List (1 .. Size);
       end record;

       type Message_Types is
          (Dispense_Acknowledgement, Dispense_Request);

       type In_Messages (Kind : Message_Types := Message_Types'First) is
       record
          case Kind is
          when Dispense_Acknowledgement =>
             Acknowledgements : Dispense_Ack;
          when Dispense_Request =>
                Request : Integer;
          end case;
       end record;
    end Message_Types;

    Msg : Message_Types.In_Messages :=
       (Kind => Message_Types.Dispense_Acknowledgement,
       Acknowledgements =>
       (Size => 8,
        Dispense_Acks => (1 .. 8 => Message_Types.Acks'First) ) );
begin -- Message_Test
    null;
end Message_Test;

This is with MinGW GNAT 3.4.2.

-- 
Jeff Carter
"I would never want to belong to any club that
would have someone like me for a member."
Annie Hall
41

Re: Discriminant within discriminants

[Jeffrey R. Carter]

Dennis Lee Bieber wrote:
> On Thu, 04 May 2006 00:57:02 GMT, "Jeffrey R. Carter"
> <spam.not.jrcarter@acm.not.spam.org> declaimed the following in
> comp.lang.ada:

I deny all claims of declaiming.

>> message_test.adb:25:04: warning: variable "Msg" is not referenced
>>
> 	Well, that looks reasonable...

Sure. The point is, I don't get an error, which the OP got for the same 
construct.

-- 
Jeff Carter
"All citizens will be required to change their underwear
every half hour. Underwear will be worn on the outside,
so we can check."
Bananas
29

Re: Discriminant within discriminants

[Stephen Leake]

"stuart clark" <stuart.clark@baesystems.com> writes:

> package message_types
>
>   type id_type is range 1..8;
>
>  type dispense_ack (size:id_type:=id_Type'first) is
>    record
>      dispense_acks:array(1..size) of acks;
>    end record;
>
>   type message_types(dispense_acknowledgement, dispense_request);
>
>   type in_messages(kind :msg_types:=msg_types'first) is
>    record
>     case type is
>       when dispense_acknowledgement =>
>          acknowledgements:dispense_ack;
>       when dispense_request
>          request:integer;
>     end case
>   end record;
>
> end message_types;
>
> i want to declare a message that is of dispense_acknowledgment type
> with a size of 8

Try:

procedure Message_Acks is
   type Id_Type is range 1 .. 8;

   type Acks is new Boolean;

   type Ack_List is array (Id_Type range <>) of Acks;

   type Dispense_Ack (Size : Id_Type := Id_Type'First) is record
      Dispense_Acks : Ack_List (1 .. Size);
   end record;

   type Message_Types is (Dispense_Acknowledgement, Dispense_Request);

   type In_Messages
     (Kind : Message_Types := Message_Types'First;
      Size : ID_Type := Id_Type'First) is
      record
         case Kind is
         when Dispense_Acknowledgement =>
            Acknowledgements : Dispense_Ack (Size);
         when Dispense_Request =>
            Request : Integer;
         end case;
      end record;

    Msg : In_Messages (Dispense_Acknowledgement, Size => 8);
begin -- Message_Test
    null;
end Message_Acks;

-- 
-- Stephe