package Ada_Store.Trading.Item

with Ada_Store.Trading.Department;

package Ada_Store.Trading.Item is

   type Instance   is tagged private;
   
   type Identifier is new Natural;
   
   function  Lookup
     (Item_Number : in Identifier)
      return Instance;

   procedure Create_New
     (Item_Number     : in Identifier;
      In_Department   : in Department.Identifier;
      Display_Descr   : in Short_Description;
      Price	      : in Currency;
      Weight_Required : in Boolean := False);

   procedure Remove
     (Item_Number : in Identifier);

   function  In_Department
     (Item : in Instance)
      return Department.Identifier;

   function  Display_Description
     (Item : in Instance)
      return Short_Description;

   function  Price
     (Item : in Instance)
      return Currency;

   function  Weight_Required
     (Item : in Instance)
      return Boolean;

   Invalid_Identifier : exception;
   Invalid_Price      : exception;

private
   Null_Identifier : constant Identifier := 0;

   type Instance is tagged
      record
	 Item_Number	 : Identifier := 0;
	 In_Department	 : Department.Identifier := 0;
	 Display_Descr   : Short_Description := (others => ' ');
	 Price		 : Currency := 0.0;
	 Weight_Required : Boolean := False;
      end record;

end Ada_Store.Trading.Item;

with Ada.Direct_IO;
with Ada.IO_Exceptions;

with Ada_Store.Trading.Department;
with Ada_Store.Support.Trace;

package body Ada_Store.Trading.Item is

   -- internal

   package Item_IO is new Ada.Direct_IO(Instance);
   use type Item_IO.Count;

   Database_Name  : String := "Item.dat";
   Database_File  : Item_IO.File_Type;

   procedure Database_Init is
   begin
      Support.Trace.Put("Trading.Item.Database_Init Started");
      begin
	 Item_IO.Open(Database_File,
		      Item_IO.Inout_File,
		      Database_Name);
      exception
	 when Ada.IO_Exceptions.Name_Error =>
	    Item_IO.Create(Database_File,
			   Item_IO.Inout_File,
			   Database_Name);
      end;
      Support.Trace.Put("Trading.Item.Database_Init Done");
   end Database_Init;

   function  Database_Lookup
     (Item_Number : in Identifier)
      return Item_IO.Positive_Count is

      Temp_Item : Instance;
      Index     : Item_IO.Positive_Count := 1;
   begin
      loop
	 Item_IO.Read(Database_File,
		      Temp_Item,
		      Index);

	 if Temp_Item.Item_Number = Item_Number then

	    return Index;
	 end if;

	 Index := Index + 1;
      end loop;
   exception
      when Ada.IO_Exceptions.End_Error =>
	 raise Invalid_Identifier;
   end Database_Lookup;

   -- public

   function  Lookup
     (Item_Number : in Identifier)
      return Instance is

      Temp_Item : Instance;
      Index     : Item_IO.Positive_Count;
   begin
      if Item_Number = 0 then
	 raise Invalid_Identifier;
      end if;

      Index := Database_Lookup(Item_Number);

      Item_IO.Read(Database_File,
		   Temp_Item,
		   Index);
      return Temp_Item;
   end Lookup;

   procedure Create_New
     (Item_Number   : in Identifier;
      In_Department : in Department.Identifier;
      Display_Descr : in Short_Description;
      Price	    : in Currency;
      Weight_Required : in Boolean := False) is

      Temp_Dept : Department.Instance;
      Temp_Item : Instance;
   begin
      if Item_Number = 0 then
	 raise Invalid_Identifier;
      end if;

      Temp_Dept := Department.Lookup(In_Department);

      if Price < Department.Min_Price(Temp_Dept) or
	 Price > Department.Max_Price(Temp_Dept) then

	 raise Invalid_Price;
      end if;

      Temp_Item := (Item_Number,
		    In_Department,
		    Display_Descr,
		    Price,
		    Weight_Required);

      Item_IO.Write(Database_File,
		    Temp_Item,
		    Item_IO.Size(Database_File) + 1);
   end Create_New;

   procedure Remove
     (Item_Number : in Identifier) is

      Temp_Item : Instance := (0,
			       0,
			       "*Deleted*         ",
			       0.0,
			       False);
      Index : Item_IO.Count;
   begin
      if Item_Number = 0 then
	 raise Invalid_Identifier;
      end if;

      Index := Database_Lookup(Item_Number);

      if Index = 0 then
	 raise Invalid_Identifier;
      end if;

      Item_IO.Write(Database_File,
		    Temp_Item,
		    Index);
   end Remove;

   function  In_Department
     (Item : in Instance)
      return Department.Identifier is
   begin
      return Item.In_Department;
   end In_Department;

   function  Display_Description
     (Item : in Instance)
      return Short_Description is
   begin
      return Item.Display_Descr;
   end Display_Description;

   function  Price
     (Item : in Instance)
      return Currency is
   begin
      return Item.Price;
   end Price;

   function  Weight_Required
     (Item : in Instance)
      return Boolean is
   begin
      return Item.Weight_Required;
   end Weight_Required;

begin
   Database_Init;
end Ada_Store.Trading.Item;

Contents Page

Copyright © 1996 Simon Johnston &
Addison Wesley Longman