Access Types

We continue our discussion of access types, and provide an example illustrating the use of general access types. First, we discuss dereferencing with the reserved word all, which pertains to both pool-specific and general access types. Then we discuss two other features of the language, which pertain only to general access types.

Suppose we had declared a record type, My_Rec_Type, with two integer components, Comp1 and Comp2, and then declared an access type, Rec_Ptr_Type, whose values point to values of My_Rec_Type. Now, we can write, in an executable part:

Whereas the name P2 designates or "references" an unnamed record object, the expression P2.Comp1 designates a component of the object and the expression P2.all designates the whole object -- a dereferencing operation.

A declared object can be pointed to by an access value only if it is originally declared as an aliased object -- one that can have multiple names. Now suppose we wrote, in a block that can "see" My_Rec_Type:

RecA and PA.all are two names (aliases) for the same object, and RecB and PB.all are two names (aliases) for another object. PC.all is another name, which can represent either RecA or RecB. Note the use of the 'Access attribute, not to be confused with the reserved word access.

There is a lifetime rule that says: given an access type T, X'Access yielding a result of type T is allowed only if X can live at least as long as T. This rule prevents the potential for dangling references.

Our example involves a callback situation in which a look-up table is used to get access values that select appropriate response procedures and parameters, such as the response to a button click or other event. (The events are simulated here with keyboard inputs.) We are using a technique described in Section 9.3 of [Ben-Ari98], but applied to a different situation.

In this example the event responses are simply to display one-line messages indicating that those events have occurred.

----------------------------------------------------------
----------------- Test_General_Accesses ------------------
--  This interactive program employs single keystrokes to 
--  represent two classes of events. Lower case 'u' and 
--  'd' represent a person pushing an up or down button. 
--  Upper case 'U' and 'D' represent the arrival of an 
--  up-going or down-going elevator, respectively. General
--  access types are used to reference appropriate 
--  responses and display messages. A 'Q' input is used to
--  quit the program. 
----------------------------------------------------------
with Ada.Text_IO; use Ada.Text_IO;
procedure Test_General_Accesses is
    
  -- types (1 enumeration, 2 general access, 1 record)  
  type Inputs is (Up, Down, Stop_Up, Stop_Down); -- 2 button events
                                                 -- & 2 other events
  type Message_Ptr is access constant String;
  type Procedure_Ptr is access procedure(I : in Inputs;
                                         S : in String);
  type Callbacks is
    record 
      Message : Message_Ptr;
      Action  : Procedure_Ptr;
    end record;
  
  -- aliased objects (constant)  
  Msg_Up      : aliased constant String := "the up light is on.";
  Msg_Down    : aliased constant String := "the down light is on.";
  Msg_Stop_Up : aliased constant String := "the up light is off.";
  Msg_Stop_Dn : aliased constant String := "the down light is off.";
  
  -- procedures (2 with same parameter profile)
  --------------------------------------------------
  procedure Respond_To_Button(I : in Inputs;
                              S : in String) is
  begin
    Put_Line("A traveler pushed a button and " & S);  
  end Respond_To_Button;    
  --------------------------------------------------
  procedure Respond_To_Event(I : in Inputs;
                             S : in String) is
  begin
    Put_Line("The elevator arrived and " & S);  
  end Respond_To_Event;
  --------------------------------------------------
  --  look-up table for pairs of access values    
  Callback : constant array (Inputs) of Callbacks := 
      ((Msg_Up'Access,      Respond_To_Button'Access),
       (Msg_Down'Access,    Respond_To_Button'Access),
       (Msg_Stop_Up'Access, Respond_To_Event'Access) ,
       (Msg_Stop_Dn'Access, Respond_To_Event'Access));
       
  Key         : Character;          -- keyboard input
  Valid_Input : Boolean;
  Inp         : Inputs  := Stop_up; -- button or event inputs
      
begin
    
  Put_Line("Enter u, d, U, D or Q");
  
  loop
    Valid_Input := True;
    Put(">>"); Get(Key);
    case Key is               -- translate to button or event
      when 'u' => Inp := Up;
      when 'd' => Inp := Down;
      when 'U' => Inp := Stop_Up;
      when 'D' => Inp := Stop_Down;
      when 'Q' =>
        Put_Line("Goodbye"); 
        exit;
      when others => 
        Valid_Input := False; 
        Put_Line("Invalid input, try again.");
    end case;
    
    if Valid_Input then
      Callback(Inp).Action(Inp, Callback(Inp).Message.all);
      -- Note dereferencing (Message.all) to obtain string 
      -- as second parameter of procedure call to Action. 
      -- Action turns out to be either Respond_To_Button 
      -- or Respond_To_Event.
    end if;
    
  end loop;
  
end Test_General_Accesses;
-----------------------------------------------------------

4.11 Access Types - 2