------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Cheddar is a GNU GPL real-time scheduling analysis tool.
-- This program provides services to automatically check schedulability and
-- other performance criteria of real-time architecture models.
--
-- Copyright (C) 2002-2016, Frank Singhoff, Alain Plantec, Jerome Legrand
--
-- The Cheddar project was started in 2002 by 
-- Frank Singhoff, Lab-STICC UMR 6285 laboratory, Université de Bretagne Occidentale
-- 
-- Cheddar has been published in the "Agence de Protection des Programmes/France" in 2008. 
-- Since 2008, Ellidiss technologies also contributes to the development of 
-- Cheddar and provides industrial support.
--
-- The full list of contributors and sponsors can be found in AUTHORS.txt and SPONSORS.txt
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 2 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
--
--
-- Contact : cheddar@listes.univ-brest.fr
--           
------------------------------------------------------------------------------
-- Last update : 
--    $Rev: 1249 $
--    $Date: 2014-08-28 07:02:15 +0200 (Fri, 28 Aug 2014) $
--    $Author: singhoff $
------------------------------------------------------------------------------
------------------------------------------------------------------------------

with Framework_Config;          use Framework_Config;
with Ada.Numerics.Aux;          use Ada.Numerics.Aux;
with Ada.Numerics.Float_Random; use Ada.Numerics.Float_Random;
with Ada.Strings.Unbounded;     use Ada.Strings.Unbounded;
with Time_Unit_Events;          use Time_Unit_Events;
with Laws;                      use Laws;
with Unchecked_Deallocation;

package Simulations.extended is

   function has_compatible_type
     (a    : in Simulation_Type;
      b    : in Simulation_Type)
      return Boolean;

   ------------------------------------------------------------------
   -- Type of data stored during a scheduling simulation
   ------------------------------------------------------------------

   type Simulations_Range is new Integer range 0 .. Max_Simulation;
   type Sum_Simulations_Range is new Integer range 0 .. Sum_Simulation;

   type Random_Law_Parameters_Type is record
      Law        : Laws_Type;
      Parameter1 : Integer;
      Parameter2 : Integer;
   end record;

   type Boolean_Table is array (Simulations_Range) of Boolean;
   type Integer_Table is array (Simulations_Range) of Integer;
   type Double_Table is array (Simulations_Range) of Double;
   type String_Table is array (Simulations_Range) of Unbounded_String;
   type Random_Table is array (Simulations_Range) of State;

   type Boolean_Time_Unit_Table is array (Time_Unit_Range) of Boolean;
   type Integer_Time_Unit_Table is array (Time_Unit_Range) of Integer;
   type Double_Time_Unit_Table is array (Time_Unit_Range) of Double;
   type String_Time_Unit_Table is array (Time_Unit_Range) of Unbounded_String;
   type Random_Time_Unit_Table is array (Time_Unit_Range) of State;

   type Simulation_Value (Ptype : Simulation_Type) is record
      case Ptype is
      when Simulation_Boolean =>
         Boolean_Value : Boolean := True;
      when Simulation_Integer | Simulation_clock =>
         Integer_Value : Integer := 0;
      when Simulation_Double =>
         Double_Value : Double := 0.0;
      when Simulation_Random =>
         Random_Value          : State;
         Random_Law_Parameters : Random_Law_Parameters_Type;
      when Simulation_String =>
         String_Value : Unbounded_String;

      when Simulation_Array_Boolean =>
         Boolean_Table_Value : Boolean_Table := (others => True);
      when Simulation_Array_Integer | Simulation_array_clock =>
         Integer_Table_Value : Integer_Table := (others => 0);
      when Simulation_Array_Double =>
         Double_Table_Value : Double_Table := (others => 0.0);
      when Simulation_Array_Random =>
         Random_Table_Value          : Random_Table;
         Random_Table_Law_Parameters : Random_Law_Parameters_Type;
      when Simulation_Array_String =>
         String_Table_Value : String_Table;

      when Simulation_Time_Unit_Array_Integer =>
         Integer_Time_Unit_Table_Value : Integer_Time_Unit_Table :=
           (others => 0);
      when Simulation_Time_Unit_Array_Double =>
         Double_Time_Unit_Table_Value : Double_Time_Unit_Table :=
           (others => 0.0);
      when Simulation_Time_Unit_Array_String =>
         String_Time_Unit_Table_Value : String_Time_Unit_Table;
      when Simulation_Time_Unit_Array_Boolean =>
         boolean_Time_Unit_Table_Value : Boolean_Time_Unit_Table;

      end case;
   end record;

   type Simulation_Value_Ptr is access Simulation_Value;

   procedure Free is new Unchecked_Deallocation (
      Simulation_Value,
      Simulation_Value_Ptr);

   procedure Put (S : Simulation_Value_Ptr);

   function To_Unbounded_String
     (S        : in Simulation_Value_Ptr;
      From, To : in Natural)
      return     Unbounded_String;

   function To_Unbounded_String
     (S    : in Simulation_Value_Ptr)
      return Unbounded_String;

   function Copy
     (My_Simulation : in Simulation_Value_Ptr)
      return          Simulation_Value_Ptr;

end Simulations.extended;