------------------------------------------------------------------------------
------------------------------------------------------------------------------
--  This Ada package was automatically generated by the software engineering
--tool Platypus
--  see http://cassoulet.univ-brest.fr/mme
--
--  Any modification of this file will be lost.
--  Please see the "platypus" directory instead : it contains the Cheddar's
--  model and its meta-model.
------------------------------------------------------------------------------

------------------------------------------------------------------------------
-- Cheddar is a free real time scheduling tool.
-- This program provides services to automatically check temporal constraints
-- of real time tasks.
--
-- Copyright (C) 2002-2009   Frank Singhoff
-- Cheddar is developed by the LISYC Team, University of Brest
--
-- 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
-- 	To post to this mailing list, you must be subscribed
-- 	(see http//beru.univ-brest.fr/~singhoff/cheddar for details)
--
------------------------------------------------------------------------------
------------------------------------------------------------------------------

with primitive_xml_strings; use primitive_xml_strings;

with Unbounded_Strings; use Unbounded_Strings;
with debug; use debug;

with Ada.Strings.Unbounded.Text_IO; use Ada.Strings.Unbounded.Text_IO;

use Unbounded_Strings.Unbounded_String_List_Package;

with Tasks; use Tasks;

with Task_Dependencies; use Task_Dependencies;
use Task_Dependencies.Half_Dep_Set;

with Task_Set; use Task_Set;

with Buffers; use Buffers;

with Generic_Graph; use Generic_Graph;
use Generic_Graph.Edge_Lists_Package;
use Generic_Graph.Node_Lists_Package;
with Generic_Graph.Extended;
use Generic_Graph.Extended;

with Systems; use Systems;


with debug; use debug;

with Messages; use Messages;

with Dependencies; use Dependencies;

with Resources; use Resources;

with Processors; use Processors;

package body DP_Graph.extended is

   -- --------= Task_Node =--------

   procedure Add_Node
     (obj     : in out Graph;
      N       : in Task_Node_Ptr;
      succeed : out Boolean)
   is
   begin
      Add_Generic_Node (obj, Generic_Node_Ptr (N), succeed);
   end Add_Node;

   procedure Initialize (obj : in out Task_Node_Ptr) is
   begin
      obj := new Task_Node;
      Initialize (Generic_Node'Class (obj.all));
      obj.TaskRef := null;
      obj.Kind    := Periodic_Type;
     -- obj.Cpu     := Empty_String;
   end Initialize;

   function Copy (obj : in Task_Node) return Task_Node_Ptr is
      New_Task_Node : Task_Node_Ptr;
   begin
      New_Task_Node := new Task_Node'(obj);
      return (New_Task_Node);
   end Copy;

   function Copy (obj : in Task_Node_Ptr) return Task_Node_Ptr is
   begin
      if (obj = null) then
         raise Building_Graph_Exception;
      else
         return Copy (obj);
      end if;
   end Copy;


   function Get_Name (obj : in Task_Node) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function Get_Name (obj : in Task_Node_Ptr) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function type_of (obj : in Task_Node) return Unbounded_String_List is
      list : Unbounded_String_List;
      s    : Unbounded_String_Ptr;
   begin
      Initialize (list);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("OBJECTS.GENERIC_OBJECT");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("GENERIC_GRAPH.GENERIC_NODE");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("DP_GRAPH.TASK_NODE");
      Add (list, s);

      return list;
   end type_of;

   function XML_String
     (obj   : in Task_Node)
      return  Unbounded_String
   is
      result : Unbounded_String;
   begin
      result := "<Task_Node id=""" & Get_Name (obj) & """ >" & Unbounded_Lf;
      Build_Attributes_XML_String (obj, result);
      result := result & "</Task_Node>" & Unbounded_Lf;
      return (result);
   end XML_String;


   function Create_Node_From_Task
     (obj  : in Generic_Task_Ptr)
      return Task_Node_Ptr
   is
      res : Task_Node_Ptr;
   begin
      Initialize (res);
      res.all.Id      := obj.all.cheddar_private_Id;
      res.all.cheddar_private_Id := obj.all.cheddar_private_Id;
      res.all.TaskRef := obj;
      res.all.Kind    := obj.all.task_type;
	put_debug("Node Id" &res.all.Id);
	put_debug("Task Id" &obj.all.cheddar_private_Id);
      return res;
   end Create_Node_From_Task;

   -- --------= Time_Triggered_Communication_Edge =--------

   procedure Add_Edge
     (obj     : in out Graph;
      E       : in Time_Triggered_Communication_Edge_Ptr;
      succeed : out Boolean)
   is
   begin
      Add_Generic_Edge (obj, Generic_Edge_Ptr (E), succeed);
   end Add_Edge;

   procedure Initialize (obj : in out Time_Triggered_Communication_Edge) is
   begin
      Initialize (Generic_Edge (obj));
      obj.Timing_Property := Sampled_Timing;
   end Initialize;

   procedure Initialize (obj : in out Time_Triggered_Communication_Edge_Ptr) is
   begin
      obj := new Time_Triggered_Communication_Edge;
      Initialize (Generic_Edge'Class (obj.all));
      obj.Timing_Property := Sampled_Timing;
   end Initialize;

   function Copy
     (obj  : in Time_Triggered_Communication_Edge)
      return Time_Triggered_Communication_Edge_Ptr
   is
      New_Time_Triggered_Communication_Edge : Time_Triggered_Communication_Edge_Ptr;
   begin
      New_Time_Triggered_Communication_Edge := new Time_Triggered_Communication_Edge'(obj);
      return (New_Time_Triggered_Communication_Edge);
   end Copy;

   procedure Put (obj : in Time_Triggered_Communication_Edge) is
   begin
      Put (Generic_Edge (obj));
      Put ("Timing_Property: ");
      Put (obj.Timing_Property'Img);
      Put ("; ");
   end Put;

   procedure Put_Name (obj : in Time_Triggered_Communication_Edge_Ptr) is
   begin
      Put (To_String (obj.cheddar_private_id));
   end Put_Name;

   function Get_Name
     (obj  : in Time_Triggered_Communication_Edge)
      return Unbounded_String
   is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function Get_Name
     (obj  : in Time_Triggered_Communication_Edge_Ptr)
      return Unbounded_String
   is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function type_of
     (obj  : in Time_Triggered_Communication_Edge)
      return Unbounded_String_List
   is
      list : Unbounded_String_List;
      s    : Unbounded_String_Ptr;
   begin
      Initialize (list);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("OBJECTS.GENERIC_OBJECT");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("GENERIC_GRAPH.GENERIC_EDGE");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("DP_GRAPH.Time_Triggered_Communication_EDGE");
      Add (list, s);

      return list;
   end type_of;

   procedure Build_Attributes_XML_String
     (obj    : in Time_Triggered_Communication_Edge;
      result : in out Unbounded_String)
   is
   begin
      Build_Attributes_XML_String (Generic_Edge (obj), result);
      result := result &
                ASCII.HT &
                "<Timing_Property> " &
                XML_String (obj.Timing_Property) &
                " </Timing_Property>" &
                Unbounded_Lf;
   end Build_Attributes_XML_String;

   function XML_String
     (obj   : in Time_Triggered_Communication_Edge)
      return  Unbounded_String
   is
      result : Unbounded_String;
   begin
      result := "<Time_Triggered_Communication_Edge id=""" &
                Get_Name (obj) &
                """ >" &
                Unbounded_Lf;
      Build_Attributes_XML_String (obj, result);
      result := result & "</Time_Triggered_Communication_Edge>" & Unbounded_Lf;
      return (result);
   end XML_String;

   function Create_Time_Triggered_Communication_Edge_From_Dependency
     (obj        : in Dependency_Ptr;
      Naming_Cpt : in Integer)
      return       Time_Triggered_Communication_Edge_Ptr
   is
      res : Time_Triggered_Communication_Edge_Ptr;
   begin
      Initialize (res);
      res.all.Id              :=
         To_Unbounded_String ("Edge_" & (Naming_Cpt'Img));
      res.all.Node_1          :=
        obj.all.Time_Triggered_Communication_source.all.cheddar_private_id;
      res.all.Node_2          := obj.all.Time_Triggered_Communication_sink.all.cheddar_private_id;
      res.all.Timing_Property := obj.all.time_triggered_timing_property;
      return res;
   end Create_Time_Triggered_Communication_Edge_From_Dependency;

   -- --------= Resource_Edge =--------

   procedure Add_Edge
     (obj     : in out Graph;
      E       : in Resource_Edge_Ptr;
      succeed : out Boolean)
   is
   begin
      Add_Generic_Edge (obj, Generic_Edge_Ptr (E), succeed);
   end Add_Edge;

   procedure Initialize (obj : in out Resource_Edge) is
   begin
      Initialize (Generic_Edge (obj));
      obj.Resource_Dependency_Resource := new Generic_Resource;
   end Initialize;

   procedure Initialize (obj : in out Resource_Edge_Ptr) is
   begin
      obj := new Resource_Edge;
      Initialize (Generic_Edge'Class (obj.all));
      obj.Resource_Dependency_Resource := new Generic_Resource;
   end Initialize;

   function Copy (obj : in Resource_Edge) return Resource_Edge_Ptr is
      New_Resource_Edge : Resource_Edge_Ptr;
   begin
      New_Resource_Edge := new Resource_Edge'(obj);
      return (New_Resource_Edge);
   end Copy;

   procedure Put (obj : in Resource_Edge) is
   begin
      Put (Generic_Edge (obj));
      Put ("Resource_Dependency_Resource: ");
      Put (obj.Resource_Dependency_Resource);
      Put ("; ");
   end Put;

   procedure Put_Name (obj : in Resource_Edge_Ptr) is
   begin
      Put (To_String (obj.cheddar_private_id));
   end Put_Name;

   function Get_Name (obj : in Resource_Edge) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function Get_Name (obj : in Resource_Edge_Ptr) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function type_of (obj : in Resource_Edge) return Unbounded_String_List is
      list : Unbounded_String_List;
      s    : Unbounded_String_Ptr;
   begin
      Initialize (list);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("OBJECTS.GENERIC_OBJECT");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("GENERIC_GRAPH.GENERIC_EDGE");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("DP_GRAPH.RESOURCE_EDGE");
      Add (list, s);

      return list;
   end type_of;

   procedure Build_Attributes_XML_String
     (obj    : in Resource_Edge;
      result : in out Unbounded_String)
   is
   begin
      Build_Attributes_XML_String (Generic_Edge (obj), result);

   end Build_Attributes_XML_String;

   function XML_String
     (obj   : in Resource_Edge)
      return  Unbounded_String
   is
      result : Unbounded_String;
   begin
      result := "<Resource_Edge id=""" &
                Get_Name (obj) &
                """ >" &
                Unbounded_Lf;
      Build_Attributes_XML_String (obj, result);
      result := result & "</Resource_Edge>" & Unbounded_Lf;
      return (result);
   end XML_String;

   function Create_Resource_Edge_From_Dependency
     (obj        : in Dependency_Ptr;
      Naming_Cpt : in Integer)
      return       Resource_Edge_Ptr
   is
      res : Resource_Edge_Ptr;
   begin
      Initialize (res);
      res.all.Id                           :=
         To_Unbounded_String ("Edge_" & (Naming_Cpt'Img));
      res.all.Node_1                       :=
        obj.all.resource_dependency_task.all.cheddar_private_id;
      res.all.Resource_Dependency_Resource :=
        obj.all.resource_dependency_resource;
      return res;
   end Create_Resource_Edge_From_Dependency;

   procedure Clean_Resource_Edges (obj : in out Graph) is
      E_Iterator    : Edge_Lists_Iterator;
      current_edge  : Generic_Edge_Ptr;
      E_Iterator2   : Edge_Lists_Iterator;
      current_edge2 : Generic_Edge_Ptr;
   begin
      Reset_Head_Iterator (obj.Edges, E_Iterator);
      Reset_Head_Iterator (obj.Edges, E_Iterator2);
      if not Is_Empty (obj.Edges) then
         Current_Element (obj.Edges, current_edge, E_Iterator);

         while (not Is_Tail_Element (obj.Edges, E_Iterator)) loop
            if Element_In_List
                 (To_Unbounded_String ("DP_GRAPH.RESOURCE_EDGE"),
                  type_of (current_edge))
            then
               Current_Element (obj.Edges, current_edge2, E_Iterator2);
               while (not Is_Tail_Element (obj.Edges, E_Iterator2)) loop
                  if Element_In_List
                       (To_Unbounded_String ("DP_GRAPH.RESOURCE_EDGE"),
                        type_of (current_edge2))
                  then
                     if ((Resource_Edge_Ptr (current_edge).
                          Resource_Dependency_Resource =
                          Resource_Edge_Ptr (current_edge2).
                          Resource_Dependency_Resource) and
                         not (current_edge.all.Id = current_edge2.all.Id) and
                         (current_edge.all.Node_2 = current_edge2.all.Node_2)
                         and
                         (current_edge.all.Node_1 = current_edge2.all.Node_1))
                     then
                        Delete (obj.Edges, current_edge2);
                        Reset_Head_Iterator (obj.Edges, E_Iterator2);
                        Reset_Head_Iterator (obj.Edges, E_Iterator);

                     end if;
                  end if;
                  Next_Element (obj.Edges, E_Iterator2);
                  Current_Element (obj.Edges, current_edge2, E_Iterator2);
               end loop;
               Reset_Head_Iterator (obj.Edges, E_Iterator2);
            end if;
            Next_Element (obj.Edges, E_Iterator);
            Current_Element (obj.Edges, current_edge, E_Iterator);
         end loop;
         if Element_In_List
              (To_Unbounded_String ("DP_GRAPH.RESOURCE_EDGE"),
               type_of (current_edge))
         then
            Current_Element (obj.Edges, current_edge2, E_Iterator2);
            while (not Is_Tail_Element (obj.Edges, E_Iterator2)) loop
               if Element_In_List
                    (To_Unbounded_String ("DP_GRAPH.RESOURCE_EDGE"),
                     type_of (current_edge2))
               then
                  if ((Resource_Edge_Ptr (current_edge).
                       Resource_Dependency_Resource =
                       Resource_Edge_Ptr (current_edge2).
                       Resource_Dependency_Resource) and
                      not (current_edge.all.Id = current_edge2.all.Id) and
                      (current_edge.all.Node_2 = current_edge2.all.Node_2) and
                      (current_edge.all.Node_1 = current_edge2.all.Node_1))
                  then
                     Delete (obj.Edges, current_edge2);
                     Reset_Head_Iterator (obj.Edges, E_Iterator2);
                     Reset_Head_Iterator (obj.Edges, E_Iterator);

                  end if;
               end if;
               Next_Element (obj.Edges, E_Iterator2);
               Current_Element (obj.Edges, current_edge2, E_Iterator2);
            end loop;
            Reset_Head_Iterator (obj.Edges, E_Iterator2);
         end if;

      end if;
   end Clean_Resource_Edges;

   procedure Create_Specific_Resource_Edges
     (obj        : in out Graph;
      D          : in Dependency_Ptr;
      Naming_Cpt : in out Integer;
      succeed    : out Boolean)
   is
      E_Iterator     : Edge_Lists_Iterator;
      current_edge   : Generic_Edge_Ptr;
      temporary_edge : Resource_Edge_Ptr;
   begin
      succeed := False;
      Reset_Head_Iterator (obj.Edges, E_Iterator);
      if not Is_Empty (obj.Edges) then
         Current_Element (obj.Edges, current_edge, E_Iterator);
         while (not Is_Tail_Element (obj.Edges, E_Iterator)) loop
            if Element_In_List
                 (To_Unbounded_String ("DP_GRAPH.RESOURCE_EDGE"),
                  type_of (current_edge))
            then
               if (Resource_Edge_Ptr (current_edge).
                    Resource_Dependency_Resource =
                   D.resource_dependency_resource)
               then

                  if (current_edge.all.Node_2 = Empty_String) then
                     current_edge.all.Node_2 :=
                        Get_Name (D.all.resource_dependency_task);
                     succeed                 := True;
                  else
                     temporary_edge            :=
                        Create_Resource_Edge_From_Dependency (D, Naming_Cpt);
                     Naming_Cpt                := Naming_Cpt + 1;
                     temporary_edge.all.Node_2 := current_edge.all.Node_2;
                     Add_Edge (obj, Copy (temporary_edge), succeed);
                     temporary_edge            :=
                        Create_Resource_Edge_From_Dependency (D, Naming_Cpt);
                     Naming_Cpt                := Naming_Cpt + 1;
                     temporary_edge.all.Node_2 := current_edge.all.Node_1;
                     Add_Edge (obj, Copy (temporary_edge), succeed);
                  end if;
               end if;
            end if;
            Next_Element (obj.Edges, E_Iterator);
            Current_Element (obj.Edges, current_edge, E_Iterator);
         end loop;
         if Element_In_List
              (To_Unbounded_String ("DP_GRAPH.RESOURCE_EDGE"),
               type_of (current_edge))
         then
            if (Resource_Edge_Ptr (current_edge).Resource_Dependency_Resource =
                D.resource_dependency_resource)
            then

               if (current_edge.all.Node_2 = Empty_String) then
                  current_edge.all.Node_2 :=
                     Get_Name (D.all.resource_dependency_task);
                  succeed                 := True;
               else
                  temporary_edge            :=
                     Create_Resource_Edge_From_Dependency (D, Naming_Cpt);
                  Naming_Cpt                := Naming_Cpt + 1;
                  temporary_edge.all.Node_2 := current_edge.all.Node_2;
                  Add_Edge (obj, Copy (temporary_edge), succeed);
                  temporary_edge            :=
                     Create_Resource_Edge_From_Dependency (D, Naming_Cpt);
                  Naming_Cpt                := Naming_Cpt + 1;
                  temporary_edge.all.Node_2 := current_edge.all.Node_1;
                  Add_Edge (obj, Copy (temporary_edge), succeed);
               end if;
            end if;
         end if;
      end if;
      if not succeed then
         Add_Edge
           (obj,
            Create_Resource_Edge_From_Dependency (D, Naming_Cpt),
            succeed);
      end if;
      if not succeed then
         raise Building_Graph_Exception;
      end if;
      Naming_Cpt := Naming_Cpt + 1;
   end Create_Specific_Resource_Edges;

   -- --------= Precedence_Edge =--------

   procedure Add_Edge
     (obj     : in out Graph;
      E       : in Precedence_Edge_Ptr;
      succeed : out Boolean)
   is
   begin
      Add_Generic_Edge (obj, Generic_Edge_Ptr (E), succeed);
   end Add_Edge;

   procedure Initialize (obj : in out Precedence_Edge) is
   begin
      Initialize (Generic_Edge (obj));
   end Initialize;

   procedure Initialize (obj : in out Precedence_Edge_Ptr) is
   begin
      obj := new Precedence_Edge;
      Initialize (Generic_Edge'Class (obj.all));
   end Initialize;

   function Copy (obj : in Precedence_Edge) return Precedence_Edge_Ptr is
      New_Precedence_Edge : Precedence_Edge_Ptr;
   begin
      New_Precedence_Edge := new Precedence_Edge'(obj);
      return (New_Precedence_Edge);
   end Copy;

   procedure Put (obj : in Precedence_Edge) is
   begin
      Put (Generic_Edge (obj));
   end Put;

   procedure Put_Name (obj : in Precedence_Edge_Ptr) is
   begin
      Put (To_String (obj.cheddar_private_id));
   end Put_Name;

   function Get_Name (obj : in Precedence_Edge) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function Get_Name (obj : in Precedence_Edge_Ptr) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function type_of (obj : in Precedence_Edge) return Unbounded_String_List is
      list : Unbounded_String_List;
      s    : Unbounded_String_Ptr;
   begin
      Initialize (list);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("OBJECTS.GENERIC_OBJECT");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("GENERIC_GRAPH.GENERIC_EDGE");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("DP_GRAPH.PRECEDENCE_EDGE");
      Add (list, s);

      return list;
   end type_of;

   procedure Build_Attributes_XML_String
     (obj    : in Precedence_Edge;
      result : in out Unbounded_String)
   is
   begin
      Build_Attributes_XML_String (Generic_Edge (obj), result);
   end Build_Attributes_XML_String;

   function XML_String
     (obj   : in Precedence_Edge)
      return  Unbounded_String
   is
      result : Unbounded_String;
   begin
      result := "<Precedence_Edge id=""" &
                Get_Name (obj) &
                """ >" &
                Unbounded_Lf;
      Build_Attributes_XML_String (obj, result);
      result := result & "</Precedence_Edge>" & Unbounded_Lf;
      return (result);
   end XML_String;


   function Create_Precedence_Edge_From_Dependency
     (obj        : in Dependency_Ptr;
      Naming_Cpt : in Integer)
      return       Precedence_Edge_Ptr
   is
      res : Precedence_Edge_Ptr;
   begin
      Initialize (res);
      res.all.Id     := To_Unbounded_String ("Edge_" & (Naming_Cpt'Img));
      res.all.Node_1 := obj.all.precedence_source.all.cheddar_private_id;
      res.all.Node_2 := obj.all.precedence_sink.all.cheddar_private_id;

      return res;
   end Create_Precedence_Edge_From_Dependency;

   -- --------= Communication_Edge =--------

   procedure Add_Edge
     (obj     : in out Graph;
      E       : in Communication_Edge_Ptr;
      succeed : out Boolean)
   is
   begin
      Add_Generic_Edge (obj, Generic_Edge_Ptr (E), succeed);
   end Add_Edge;

   procedure Initialize (obj : in out Communication_Edge) is
   begin
      Initialize (Generic_Edge (obj));
      obj.Communication_Dependency_Object := new Periodic_Message;
      Initialize (obj.Communication_Dependency_Object.all);
   end Initialize;

   procedure Initialize (obj : in out Communication_Edge_Ptr) is
   begin
      obj := new Communication_Edge;
      Initialize (Generic_Edge'Class (obj.all));
      obj.all.Communication_Dependency_Object := new Periodic_Message;
      Initialize (obj.all.Communication_Dependency_Object.all);
   end Initialize;

   function Create_Communication_Edge_From_Dependency
     (obj        : in Dependency_Ptr;
      Naming_Cpt : in Integer)
      return       Communication_Edge_Ptr
   is
      res : Communication_Edge_Ptr;
   begin
      Initialize (res);
      res.all.Id := To_Unbounded_String ("Edge_" & (Naming_Cpt'Img));
      if (obj.all.asynchronous_communication_orientation = From_Task_To_Object) then
         res.all.Node_1 := obj.all.asynchronous_communication_dependent_task.all.cheddar_private_id;
      else
         res.all.Node_2 := obj.all.asynchronous_communication_dependent_task.all.cheddar_private_id;
      end if;
      res.all.Communication_Dependency_Object :=
        obj.all.asynchronous_communication_dependency_object;
      return res;
   end Create_Communication_Edge_From_Dependency;

   procedure Create_Specific_Communication_Edges
     (obj        : in out Graph;
      D          : in Dependency_Ptr;
      Naming_Cpt : in out Integer;
      succeed    : out Boolean)
   is
      E_Iterator     : Edge_Lists_Iterator;
      current_edge   : Generic_Edge_Ptr;
      temporary_edge : Communication_Edge_Ptr;
   begin
      succeed := False;
      Reset_Head_Iterator (obj.Edges, E_Iterator);
      if not Is_Empty (obj.Edges) then
         Current_Element (obj.Edges, current_edge, E_Iterator);
         while (not Is_Tail_Element (obj.Edges, E_Iterator)) loop
            if Element_In_List
                 (To_Unbounded_String ("DP_GRAPH.COMMUNICATION_EDGE"),
                  type_of (current_edge))
            then
               if (Communication_Edge_Ptr (current_edge).
                    Communication_Dependency_Object =
                   D.asynchronous_communication_dependency_object)
               then
                  if (D.all.asynchronous_communication_orientation =
                      From_Task_To_Object)
                  then
                     if (current_edge.all.Node_1 = Empty_String) then
                        current_edge.all.Node_1 :=
                           Get_Name (D.all.asynchronous_communication_dependent_task);
                        succeed                 := True;
                     else
                        if not (current_edge.all.Node_2 = Empty_String) then
                           temporary_edge            :=
                              Create_Communication_Edge_From_Dependency
                                (D,
                                 Naming_Cpt);
                           Naming_Cpt                := Naming_Cpt + 1;
                           temporary_edge.all.Node_2 :=
                             current_edge.all.Node_2;
                           Add_Edge (obj, Copy (temporary_edge), succeed);
                        end if;
                     end if;
                  else
                     if (current_edge.all.Node_2 = Empty_String) then
                        current_edge.all.Node_2 :=
                           Get_Name (D.all.asynchronous_communication_dependent_task);
                        succeed                 := True;
                     else
                        if not (current_edge.Node_1 = Empty_String) then
                           temporary_edge            :=
                              Create_Communication_Edge_From_Dependency
                                (D,
                                 Naming_Cpt);
                           Naming_Cpt                := Naming_Cpt + 1;
                           temporary_edge.all.Node_1 :=
                             current_edge.all.Node_1;
                           Add_Edge (obj, Copy (temporary_edge), succeed);
                        end if;
                     end if;
                  end if;
               end if;
            end if;
            Next_Element (obj.Edges, E_Iterator);
            Current_Element (obj.Edges, current_edge, E_Iterator);
         end loop;
         if Element_In_List
              (To_Unbounded_String ("DP_GRAPH.COMMUNICATION_EDGE"),
               type_of (current_edge))
         then
            if (Communication_Edge_Ptr (current_edge).
                 Communication_Dependency_Object =
                D.asynchronous_communication_dependency_object)
            then
               if (D.all.asynchronous_communication_orientation =
                   From_Task_To_Object)
               then
                  if (current_edge.all.Node_1 = Empty_String) then
                     current_edge.all.Node_1 :=
                        Get_Name (D.all.asynchronous_communication_dependent_task);
                     succeed                 := True;
                  else
                     if not (current_edge.all.Node_2 = Empty_String) then
                        temporary_edge            :=
                           Create_Communication_Edge_From_Dependency
                             (D,
                              Naming_Cpt);
                        Naming_Cpt                := Naming_Cpt + 1;
                        temporary_edge.all.Node_2 := current_edge.all.Node_2;
                        Add_Edge (obj, Copy (temporary_edge), succeed);
                     end if;
                  end if;
               else
                  if (current_edge.all.Node_2 = Empty_String) then
                     current_edge.all.Node_2 :=
                        Get_Name (D.all.asynchronous_communication_dependent_task);
                     succeed                 := True;
                  else
                     if not (current_edge.all.Node_1 = Empty_String) then
                        temporary_edge            :=
                           Create_Communication_Edge_From_Dependency
                             (D,
                              Naming_Cpt);
                        Naming_Cpt                := Naming_Cpt + 1;
                        temporary_edge.all.Node_1 := current_edge.all.Node_1;
                        Add_Edge (obj, Copy (temporary_edge), succeed);
                     end if;
                  end if;
               end if;
            end if;
         end if;
      end if;
      if not succeed then
         Add_Edge
           (obj,
            Create_Communication_Edge_From_Dependency (D, Naming_Cpt),
            succeed);
      end if;
      if not succeed then
         raise Building_Graph_Exception;
      end if;
      Naming_Cpt := Naming_Cpt + 1;
   end Create_Specific_Communication_Edges;

   function Copy
     (obj  : in Communication_Edge)
      return Communication_Edge_Ptr
   is
      New_Communication_Edge : Communication_Edge_Ptr;
   begin
      New_Communication_Edge := new Communication_Edge'(obj);
      return (New_Communication_Edge);
   end Copy;

   procedure Put (obj : in Communication_Edge) is
   begin
      Put (Generic_Edge (obj));
      Put ("Communication_Dependency_Object: ");
      if obj.Communication_Dependency_Object /= null then
         Put (obj.Communication_Dependency_Object.all);
      else
         Put ("null");
      end if;
      Put ("; ");
   end Put;

   procedure Put_Name (obj : in Communication_Edge_Ptr) is
   begin
      Put (To_String (obj.cheddar_private_id));
   end Put_Name;

   function Get_Name (obj : in Communication_Edge) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function Get_Name
     (obj  : in Communication_Edge_Ptr)
      return Unbounded_String
   is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function type_of
     (obj  : in Communication_Edge)
      return Unbounded_String_List
   is
      list : Unbounded_String_List;
      s    : Unbounded_String_Ptr;
   begin
      Initialize (list);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("OBJECTS.GENERIC_OBJECT");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("GENERIC_GRAPH.GENERIC_EDGE");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("DP_GRAPH.COMMUNICATION_EDGE");
      Add (list, s);

      return list;
   end type_of;

   procedure Build_Attributes_XML_String
     (obj    : in Communication_Edge;
      result : in out Unbounded_String)
   is
   begin
      Build_Attributes_XML_String (Generic_Edge (obj), result);

   end Build_Attributes_XML_String;

   function XML_String
     (obj   : in Communication_Edge)
      return  Unbounded_String
   is
      result : Unbounded_String;
   begin
      result := "<Communication_Edge id=""" &
                Get_Name (obj) &
                """ >" &
                Unbounded_Lf;
      Build_Attributes_XML_String (obj, result);
      result := result & "</Communication_Edge>" & Unbounded_Lf;
      return (result);
   end XML_String;


   -- --------= Buffer_Edge =--------

   procedure Add_Edge
     (obj     : in out Graph;
      E       : in Buffer_Edge_Ptr;
      succeed : out Boolean)
   is
   begin
      Add_Generic_Edge (obj, Generic_Edge_Ptr (E), succeed);
   end Add_Edge;

   procedure Initialize (obj : in out Buffer_Edge) is
   begin
      Initialize (Generic_Edge (obj));
      obj.Buffer_Dependency_Object := new Buffer;
      Initialize (obj.Buffer_Dependency_Object.all);
   end Initialize;

   procedure Initialize (obj : in out Buffer_Edge_Ptr) is
   begin
      obj := new Buffer_Edge;
      Initialize (Generic_Edge'Class (obj.all));
      obj.all.Buffer_Dependency_Object := new Buffer;
      Initialize (obj.Buffer_Dependency_Object.all);
   end Initialize;


   function Copy (obj : in Buffer_Edge) return Buffer_Edge_Ptr is
      New_Buffer_Edge : Buffer_Edge_Ptr;
   begin
      New_Buffer_Edge := new Buffer_Edge'(obj);
      return (New_Buffer_Edge);
   end Copy;

   procedure Put (obj : in Buffer_Edge) is
   begin
      Put (Generic_Edge (obj));
      Put ("Buffer_Dependency_Object: ");
      if obj.Buffer_Dependency_Object /= null then
         Put (obj.Buffer_Dependency_Object.all);
      else
         Put ("null");
      end if;
      Put ("; ");
   end Put;

   procedure Put_Name (obj : in Buffer_Edge_Ptr) is
   begin
      Put (To_String (obj.cheddar_private_id));
   end Put_Name;

   function Get_Name (obj : in Buffer_Edge) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function Get_Name (obj : in Buffer_Edge_Ptr) return Unbounded_String is
   begin
      return obj.cheddar_private_id;
   end Get_Name;

   function type_of (obj : in Buffer_Edge) return Unbounded_String_List is
      list : Unbounded_String_List;
      s    : Unbounded_String_Ptr;
   begin
      Initialize (list);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("OBJECTS.GENERIC_OBJECT");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("GENERIC_GRAPH.GENERIC_EDGE");
      Add (list, s);

      s     := new Unbounded_String;
      s.all := To_Unbounded_String ("DP_GRAPH.BUFFER_EDGE");
      Add (list, s);

      return list;
   end type_of;

   function Create_Buffer_Edge_From_Dependency
     (obj        : in Dependency_Ptr;
      Naming_Cpt : in Integer)
      return       Buffer_Edge_Ptr
   is
      res : Buffer_Edge_Ptr;
   begin
      Initialize (res);
      res.all.Id                       :=
         To_Unbounded_String ("Edge_" & (Naming_Cpt'Img));
      res.all.Node_1                   :=
        obj.all.buffer_dependent_task.all.cheddar_private_id;
      res.all.Buffer_Dependency_Object := obj.all.buffer_dependency_object;
      return res;
   end Create_Buffer_Edge_From_Dependency;




   procedure Create_Specific_Buffer_Edges
     (obj        : in out Graph;
      D          : in Dependency_Ptr;
      Naming_Cpt : in out Integer;
      succeed    : out Boolean)
   is
      E_Iterator     : Edge_Lists_Iterator;
      current_edge   : Generic_Edge_Ptr;
      temporary_edge : Buffer_Edge_Ptr;
   begin

      succeed := False;
      Reset_Head_Iterator (obj.Edges, E_Iterator);
      if not Is_Empty (obj.Edges) then
         Current_Element (obj.Edges, current_edge, E_Iterator);

         while (not Is_Tail_Element (obj.Edges, E_Iterator)) loop
            if Element_In_List
                 (To_Unbounded_String ("DP_GRAPH.BUFFER_EDGE"),
                  type_of (current_edge))
            then
               if (Buffer_Edge_Ptr (current_edge).Buffer_Dependency_Object =
                   D.buffer_dependency_object)
               then
                  if (D.all.buffer_orientation = From_Task_To_Object) then
                     if (current_edge.all.Node_1 = Empty_String) then
                        current_edge.all.Node_1 :=
                           Get_Name (D.all.buffer_dependent_task);
                        succeed                 := True;
                     else
                        if not (current_edge.all.Node_2 = Empty_String) then
                           temporary_edge            :=
                              Create_Buffer_Edge_From_Dependency
                                (D,
                                 Naming_Cpt);
                           Naming_Cpt                := Naming_Cpt + 1;
                           temporary_edge.all.Node_2 :=
                             current_edge.all.Node_2;
                           Add_Edge (obj, Copy (temporary_edge), succeed);
                        end if;
                     end if;
                  else
                     if (current_edge.all.Node_2 = Empty_String) then
                        current_edge.all.Node_2 :=
                           Get_Name (D.all.buffer_dependent_task);
                        succeed                 := True;
                     else
                        if not (current_edge.Node_1 = Empty_String) then
                           temporary_edge            :=
                              Create_Buffer_Edge_From_Dependency
                                (D,
                                 Naming_Cpt);
                           Naming_Cpt                := Naming_Cpt + 1;
                           temporary_edge.all.Node_1 :=
                             current_edge.all.Node_1;
                           Add_Edge (obj, Copy (temporary_edge), succeed);
                        end if;
                     end if;
                  end if;
               end if;
            end if;
            Next_Element (obj.Edges, E_Iterator);
            Current_Element (obj.Edges, current_edge, E_Iterator);
         end loop;
         if Element_In_List
              (To_Unbounded_String ("DP_GRAPH.BUFFER_EDGE"),
               type_of (current_edge))
         then
            if (Buffer_Edge_Ptr (current_edge).Buffer_Dependency_Object =
                D.buffer_dependency_object)
            then
               if (D.all.buffer_orientation = From_Task_To_Object) then
                  if (current_edge.all.Node_1 = Empty_String) then
                     current_edge.all.Node_1 :=
                        Get_Name (D.all.buffer_dependent_task);
                     succeed                 := True;
                  else
                     if not (current_edge.all.Node_2 = Empty_String) then
                        temporary_edge            :=
                           Create_Buffer_Edge_From_Dependency (D, Naming_Cpt);
                        Naming_Cpt                := Naming_Cpt + 1;
                        temporary_edge.all.Node_2 := current_edge.all.Node_2;
                        Add_Edge (obj, Copy (temporary_edge), succeed);
                     end if;
                  end if;
               else
                  if (current_edge.all.Node_2 = Empty_String) then
                     current_edge.all.Node_2 :=
                        Get_Name (D.all.buffer_dependent_task);
                     succeed                 := True;
                  else
                     if not (current_edge.all.Node_1 = Empty_String) then
                        temporary_edge            :=
                           Create_Buffer_Edge_From_Dependency (D, Naming_Cpt);
                        Naming_Cpt                := Naming_Cpt + 1;
                        temporary_edge.all.Node_1 := current_edge.all.Node_1;
                        Add_Edge (obj, Copy (temporary_edge), succeed);
                     end if;
                  end if;
               end if;
            end if;
         end if;
      end if;
      if not succeed then
         Add_Edge
           (obj,
            Create_Buffer_Edge_From_Dependency (D, Naming_Cpt),
            succeed);
      end if;
      if not succeed then
         raise Building_Graph_Exception;
      end if;
      Naming_Cpt := Naming_Cpt + 1;
   end Create_Specific_Buffer_Edges;



   function Build_Graph_From_System (obj : System) return Graph is
      built_graph        : Graph;
      t_iterator         : Tasks_Iterator;
      current_task       : Generic_Task_Ptr;
      d_iterator         : Tasks_Dependencies_Iterator;
      current_dependency : Dependency_Ptr;
      succeed            : Boolean;
      Naming_Cpt         : Integer;
   begin
      Naming_Cpt := 1;
      Initialize (built_graph);
      Reset_Iterator (obj.Tasks, t_iterator);
      Current_Element (obj.Tasks, current_task, t_iterator);
      -- First Step : adding all task_nodes
      while (not Is_Last_Element (obj.Tasks, t_iterator)) loop
         Add_Node
           (built_graph,
            Create_Node_From_Task (current_task),
            succeed);
	put_debug("*******************Building Graph");
         Next_Element (obj.Tasks, t_iterator);
         Current_Element (obj.Tasks, current_task, t_iterator);
         if not succeed then
            raise Building_Graph_Exception;
         end if;
      end loop;
      Add_Node (built_graph, Create_Node_From_Task (current_task), succeed);

      if (not Is_Empty (obj.Dependencies.all.Depends)) then

         Reset_Iterator (obj.Dependencies.all.Depends, d_iterator);
         Current_Element
           (obj.Dependencies.all.Depends,
            current_dependency,
            d_iterator);

         while (not Is_Last_Element
                      (obj.Dependencies.all.Depends,
                       d_iterator))
         loop

            case current_dependency.type_of_dependency is
               when Precedence_Dependency| remote_procedure_call_dependency  =>
                  Add_Edge
                    (built_graph,
                     Create_Precedence_Edge_From_Dependency
                        (current_dependency,
                         Naming_Cpt),
                     succeed);
                  if not succeed then
                     raise Building_Graph_Exception;
                  end if;
                  Naming_Cpt := Naming_Cpt + 1;

               when Queueing_Buffer_Dependency =>
                  Create_Specific_Buffer_Edges
                    (built_graph,
                     current_dependency,
                     Naming_Cpt,
                     succeed);
                  if not succeed then
                     raise Building_Graph_Exception;
                  end if;

               when asynchronous_Communication_Dependency =>
                  Create_Specific_Communication_Edges
                    (built_graph,
                     current_dependency,
                     Naming_Cpt,
                     succeed);
                  if not succeed then
                     raise Building_Graph_Exception;
                  end if;

               when Time_Triggered_Communication_Dependency =>
                  Add_Edge
                    (built_graph,
                     Create_Time_Triggered_Communication_Edge_From_Dependency
                        (current_dependency,
                         Naming_Cpt),
                     succeed);
                  if not succeed then
                     raise Building_Graph_Exception;
                  end if;
                  Naming_Cpt := Naming_Cpt + 1;

               when Resource_Dependency =>
                  Create_Specific_Resource_Edges
                    (built_graph,
                     current_dependency,
                     Naming_Cpt,
                     succeed);
                  if not succeed then
                     raise Building_Graph_Exception;
                  end if;
                  Naming_Cpt := Naming_Cpt + 1;
               when Black_Board_buffer_Dependency =>
                 null;

            end case;

            Next_Element (obj.Dependencies.all.Depends, d_iterator);
            Current_Element
              (obj.Dependencies.all.Depends,
               current_dependency,
               d_iterator);
         end loop;

         case current_dependency.type_of_dependency is
            when Precedence_Dependency | remote_procedure_call_dependency =>
               Add_Edge
                 (built_graph,
                  Create_Precedence_Edge_From_Dependency
                     (current_dependency,
                      Naming_Cpt),
                  succeed);
               if not succeed then
                  raise Building_Graph_Exception;
               end if;
               Naming_Cpt := Naming_Cpt + 1;

            when Queueing_Buffer_Dependency =>
               Create_Specific_Buffer_Edges
                 (built_graph,
                  current_dependency,
                  Naming_Cpt,
                  succeed);
               if not succeed then
                  raise Building_Graph_Exception;
               end if;

            when asynchronous_Communication_Dependency =>
               Create_Specific_Communication_Edges
                 (built_graph,
                  current_dependency,
                  Naming_Cpt,
                  succeed);
               if not succeed then
                  raise Building_Graph_Exception;
               end if;

            when Time_Triggered_Communication_Dependency =>
               Add_Edge
                 (built_graph,
                  Create_Time_Triggered_Communication_Edge_From_Dependency
                     (current_dependency,
                      Naming_Cpt),
                  succeed);
               if not succeed then
                  raise Building_Graph_Exception;
               end if;
               Naming_Cpt := Naming_Cpt + 1;

            when Resource_Dependency =>
               Create_Specific_Resource_Edges
                 (built_graph,
                  current_dependency,
                  Naming_Cpt,
                  succeed);
               if not succeed then
                  raise Building_Graph_Exception;
               end if;
               Naming_Cpt := Naming_Cpt + 1;

            when Black_Board_buffer_Dependency =>
                 null;

         end case;
      end if;
      Clean_Resource_Edges (built_graph);
      return built_graph;
   end Build_Graph_From_System;

   function get_value (obj : Graph_Ptr) return Graph is
      return_graph : Graph;
      temp         : Graph_Ptr;
   begin
      Initialize (return_graph);
      temp               := Copy (obj);
      return_graph.Edges := temp.Edges;
      return_graph.Nodes := temp.Nodes;

      return return_graph;
   end get_value;

end DP_Graph.extended;