Object-oriented programming

Simple type extension

Goal: work with type extensions using record types containing numeric components.

Steps:

1. Implement the Type_Extensions package.

   1. Declare the record type T_Float.

   2. Declare the record type T_Mixed

   3. Implement the Init function for the T_Float type with a floating-point input parameter.

   4. Implement the Init function for the T_Float type with an integer input parameter.

   5. Implement the Image function for the T_Float type.

   6. Implement the Init function for the T_Mixed type with a floating-point input parameter.

   7. Implement the Init function for the T_Mixed type with an integer input parameter.

   8. Implement the Image function for the T_Mixed type.

Requirements:

1. Record type T_Float contains the following component:

   1. F, a floating-point type.

2. Record type T_Mixed is derived from the T_Float type.

   1. T_Mixed extends T_Float with the following component:

      1. I, an integer component.

   2. Both components must be numerically synchronized:

      • For example, if the floating-point component contains the value 2.0, the value of the integer component must be 2.

      • In order to simplify the implementation, you can simply use Integer (F) to convert a floating-point variable F to integer.

3. Function Init returns an object of the corresponding type (T_Float or T_Mixed).

   1. For each type, two versions of Init must be declared:

      1. one with a floating-point input parameter,

      2. another with an integer input parameter.

   2. The parameter to Init is used to initialize the record components.

4. Function Image returns a string for the components of the record type.

   1. In case of the Image function for the T_Float type, the string must have the format "{ F => <float value> }".

      • For example, the call Image (T_Float'(Init (8.0)))) should return the string "{ F => 8.00000E+00 }".

   2. In case of the Image function for the T_Mixed type, the string must have the format "{ F => <float value>, I => <integer value> }".

      • For example, the call Image (T_Mixed'(Init (8.0)))) should return the string "{ F => 8.00000E+00, I => 8 }".

    
        
in 0:Type_Extension_Chk
out 0:T_Mixed is in T_Float'Class as expected F1: { F =>  2.00000E+00 } F2: { F =>  3.00000E+00 } M1: { F =>  4.00000E+00, I =>  4 } M2: { F =>  5.00000E+00, I =>  5 }
    
    
    
        
package Type_Extensions is

   --  Create declaration of T_Float type!
   type T_Float is null record;

   --  function Init ...

   --  function Image ...

   --  Create declaration of T_Mixed type!
   type T_Mixed is null record;

end Type_Extensions;
    
        
package body Type_Extensions is

end Type_Extensions;
    
        
with Ada.Command_Line; use Ada.Command_Line;
with Ada.Text_IO;      use Ada.Text_IO;

with Type_Extensions;  use Type_Extensions;

procedure Main is

   type Test_Case_Index is
     (Type_Extension_Chk);

   procedure Check (TC : Test_Case_Index) is
      F1, F2 : T_Float;
      M1, M2 : T_Mixed;
   begin
      case TC is
      when Type_Extension_Chk =>
         F1 := Init (2.0);
         F2 := Init (3);
         M1 := Init (4.0);
         M2 := Init (5);

         if M2 in T_Float'Class then
           Put_Line ("T_Mixed is in T_Float'Class as expected");
         end if;

         Put_Line ("F1: " & Image (F1));
         Put_Line ("F2: " & Image (F2));
         Put_Line ("M1: " & Image (M1));
         Put_Line ("M2: " & Image (M2));
      end case;
   end Check;

begin
   if Argument_Count < 1 then
      Put_Line ("ERROR: missing arguments! Exiting...");
      return;
   elsif Argument_Count > 1 then
      Put_Line ("Ignoring additional arguments...");
   end if;

   Check (Test_Case_Index'Value (Argument (1)));
end Main;
    
    

        
            type_extensions.ads
        
            type_extensions.adb
        
            main.adb
        
    
    

    

        

            
                
                Settings
            
            

                
                    
                    Enable tabbed editor view for this editor
                
                
                    
                    Use the dark theme
                
            
        
        
            
            Reset
        
        
            
            Download
        
    
    

        

            
                Submit
            
        
        

            

            
                

            
        
    

Online Store

Goal: create an online store for the members of an association.

Steps:

1. Implement the Online_Store package.

   1. Declare the Member type.

   2. Declare the Full_Member type.

   3. Implement the Get_Status function for the Member type.

   4. Implement the Get_Price function for the Member type.

   5. Implement the Get_Status function for the Full_Member type.

   6. Implement the Get_Price function for the Full_Member type.

2. Implement the Online_Store.Tests child package.

   1. Implement the Simple_Test procedure.

Requirements:

1. Package Online_Store implements an online store application for the members of an association.

   1. In this association, members can have one of the following status:

      • associate member, or

      • full member.

2. Function Get_Price returns the correct price of an item.

   1. Associate members must pay the full price when they buy items from the online store.

   2. Full members can get a discount.

      1. The discount rate can be different for each full member — depending on factors that are irrelevant for this exercise.

3. Package Online_Store has following types:

   1. Percentage type, which represents a percentage ranging from 0.0 to 1.0.

   2. Member type for associate members containing following components:

      • Start, which indicates the starting year of the membership.

        • This information is common for both associate and full members.

        • You can use the Year_Number type from the standard Ada.Calendar package for this component.

   3. Full_Member type for full members.

      1. This type must extend the Member type above.

      2. It contains the following additional component:

         • Discount, which indicates the discount rate that the full member gets in the online store.

           • This component must be of Percentage type.

4. For the Member and Full_Member types, you must implement the following functions:

   1. Get_Status, which returns a string with the membership status.

      • The string must be "Associate Member" or "Full Member", respectively.

   2. Get_Price, which returns the adapted price of an item — indicating the actual due amount.

      • For example, for a full member with a 10% discount rate, the actual due amount of an item with a price of 100.00 is 90.00.

      • Associated members don't get a discount, so they always pay the full price.

5. Procedure Simple_Test (from the Online_Store.Tests package) is used for testing.

   1. Based on a list of members that bought on the online store and the corresponding full price of the item, Simple_Test must display information about each member and the actual due amount after discounts.

   2. Information about the members must be displayed in the following format:

      Member # <number>
      Status: <status>
      Since:  <year>
      Due Amount:  <value>
      --------
      

   3. For this exercise, Simple_Test must use the following list:

      #	Membership status	Start (year)	Discount	Full Price
      1	Associate	2010	N/A	250.00
      2	Full	1998	10.0 %	160.00
      3	Full	1987	20.0 %	400.00
      4	Associate	2013	N/A	110.00

   4. In order to pass the tests, the information displayed by a call to Simple_Test must conform to the format described above.

      • You can find another example in the remarks below.

Remarks:

1. In previous labs, we could have implemented a simplified version of the system described above by simply using an enumeration type to specify the membership status. For example:

   type Member_Status is (Associate_Member, Full_Member);
   

   1. In this case, the Get_Price function would then evaluate the membership status and adapt the item price — assuming a fixed discount rate for all full members. This could be the corresponding function declaration:

      type Amount is delta 10.0**(-2) digits 10;
      
      function Get_Price (M : Member_Status;
                          P : Amount) return Amount;
      

   2. In this exercise, however, we'll use type extension to represent the membership status in our application.

2. For the procedure Simple_Test, let's consider the following list of members as an example:

   #	Membership status	Start (year)	Discount	Full Price
   1	Associate	2002	N/A	100.00
   2	Full	2005	10.0 %	100.00

   • For this list, the test procedure displays the following information (in this exact format):

     Member # 1
     Status: Associate Member
     Since:  2002
     Due Amount:  100.00
     --------
     Member # 2
     Status: Full Member
     Since:  2005
     Due Amount:  90.00
     --------
     

   • Here, although both members had the same full price (as indicated by the last column), member #2 gets a reduced due amount of 90.00 because of the full membership status.

    
        
in 0:Type_Chk
out 0:Testing Status of Associate Member Type => OK Testing Status of Full Member Type => OK Testing Discount of Associate Member Type => OK Testing Discount of Full Member Type => OK
in 1:Unit_Test_Chk
out 1:Member # 1 Status: Associate Member Since:  2010 Due Amount:  250.00 -------- Member # 2 Status: Full Member Since:  1998 Due Amount:  144.00 -------- Member # 3 Status: Full Member Since:  1987 Due Amount:  320.00 -------- Member # 4 Status: Associate Member Since:  2013 Due Amount:  110.00 --------
    
    
    
        
with Ada.Calendar; use Ada.Calendar;

package Online_Store is

   type Amount is delta 10.0**(-2) digits 10;

   subtype Percentage is Amount range 0.0 .. 1.0;

   --  Create declaration of Member type!
   --
   --  You can use Year_Number from Ada.Calendar for the membership
   --  starting year.
   --
   type Member is null record;

   function Get_Status (M : Member) return String;

   function Get_Price (M : Member;
                       P : Amount) return Amount;

   --  Create declaration of Full_Member type!
   --
   --  Use the Percentage type for storing the membership discount.
   --
   type Full_Member is null record;

   function Get_Status (M : Full_Member) return String;

   function Get_Price (M : Full_Member;
                       P : Amount) return Amount;

end Online_Store;
    
        
package body Online_Store is

   function Get_Status (M : Member) return String is
     ("");

   function Get_Status (M : Full_Member) return String is
     ("");

   function Get_Price (M : Member;
                       P : Amount) return Amount is (0.0);

   function Get_Price (M : Full_Member;
                       P : Amount) return Amount is
     (0.0);

end Online_Store;
    
        
package Online_Store.Tests is

   procedure Simple_Test;

end Online_Store.Tests;
    
        
with Ada.Text_IO; use Ada.Text_IO;

package body Online_Store.Tests is

   procedure Simple_Test is
   begin
      null;
   end Simple_Test;

end Online_Store.Tests;
    
        
with Ada.Command_Line;   use Ada.Command_Line;
with Ada.Text_IO;        use Ada.Text_IO;

with Online_Store;       use Online_Store;
with Online_Store.Tests; use Online_Store.Tests;

procedure Main is

   type Test_Case_Index is
     (Type_Chk,
      Unit_Test_Chk);

   procedure Check (TC : Test_Case_Index) is

      function Result_Image (Result : Boolean) return String is
        (if Result then "OK" else "not OK");

   begin
      case TC is
      when Type_Chk =>
         declare
            AM : constant Member      := (Start    => 2002);
            FM : constant Full_Member := (Start    => 1990,
                                          Discount => 0.2);
         begin
            Put_Line ("Testing Status of Associate Member Type => "
                      & Result_Image (AM.Get_Status = "Associate Member"));
            Put_Line ("Testing Status of Full Member Type => "
                      & Result_Image (FM.Get_Status = "Full Member"));
            Put_Line ("Testing Discount of Associate Member Type => "
                      & Result_Image (AM.Get_Price (100.0) = 100.0));
            Put_Line ("Testing Discount of Full Member Type => "
                      & Result_Image (FM.Get_Price (100.0) = 80.0));
         end;
         when Unit_Test_Chk =>
            Simple_Test;
      end case;
   end Check;

begin
   if Argument_Count < 1 then
      Put_Line ("ERROR: missing arguments! Exiting...");
      return;
   elsif Argument_Count > 1 then
      Put_Line ("Ignoring additional arguments...");
   end if;

   Check (Test_Case_Index'Value (Argument (1)));
end Main;
    
    

        
            online_store.ads
        
            online_store.adb
        
            online_store-tests.ads
        
            online_store-tests.adb
        
            main.adb
        
    
    

    

        

            
                
                Settings
            
            

                
                    
                    Enable tabbed editor view for this editor
                
                
                    
                    Use the dark theme
                
            
        
        
            
            Reset
        
        
            
            Download
        
    
    

        

            
                Submit