| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT RUN-TIME COMPONENTS -- |
| -- -- |
| -- G N A T . G R A P H S -- |
| -- -- |
| -- S p e c -- |
| -- -- |
| -- Copyright (C) 2018-2022, Free Software Foundation, Inc. -- |
| -- -- |
| -- GNAT is free software; you can redistribute it and/or modify it under -- |
| -- terms of the GNU General Public License as published by the Free Soft- -- |
| -- ware Foundation; either version 3, or (at your option) any later ver- -- |
| -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- |
| -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- |
| -- or FITNESS FOR A PARTICULAR PURPOSE. -- |
| -- -- |
| -- As a special exception under Section 7 of GPL version 3, you are granted -- |
| -- additional permissions described in the GCC Runtime Library Exception, -- |
| -- version 3.1, as published by the Free Software Foundation. -- |
| -- -- |
| -- You should have received a copy of the GNU General Public License and -- |
| -- a copy of the GCC Runtime Library Exception along with this program; -- |
| -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- |
| -- <http://www.gnu.org/licenses/>. -- |
| -- -- |
| -- GNAT was originally developed by the GNAT team at New York University. -- |
| -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
| -- -- |
| ------------------------------------------------------------------------------ |
| |
| -- Note: this unit is used during bootstrap, see ADA_GENERATED_FILES in |
| -- gcc-interface/Make-lang.in for details on the constraints. |
| |
| with GNAT.Dynamic_HTables; use GNAT.Dynamic_HTables; |
| with GNAT.Lists; use GNAT.Lists; |
| with GNAT.Sets; use GNAT.Sets; |
| |
| package GNAT.Graphs is |
| |
| --------------- |
| -- Component -- |
| --------------- |
| |
| -- The following type denotes a strongly connected component handle |
| -- (referred to as simply "component") in a graph. |
| |
| type Component_Id is new Natural; |
| No_Component : constant Component_Id := Component_Id'First; |
| |
| function Hash_Component (Comp : Component_Id) return Bucket_Range_Type; |
| -- Map component Comp into the range of buckets |
| |
| function Present (Comp : Component_Id) return Boolean; |
| -- Determine whether component Comp exists |
| |
| --------------------- |
| -- Directed_Graphs -- |
| --------------------- |
| |
| -- The following package offers a directed graph abstraction with the |
| -- following characteristics: |
| -- |
| -- * Dynamic resizing based on number of vertices and edges |
| -- * Creation of multiple instances, of different sizes |
| -- * Discovery of strongly connected components |
| -- * Iterable attributes |
| -- |
| -- The following use pattern must be employed when operating this graph: |
| -- |
| -- Graph : Directed_Graph := Create (<some size>, <some size>); |
| -- |
| -- <various operations> |
| -- |
| -- Destroy (Graph); |
| -- |
| -- The destruction of the graph reclaims all storage occupied by it. |
| |
| generic |
| |
| -------------- |
| -- Vertices -- |
| -------------- |
| |
| type Vertex_Id is private; |
| -- The handle of a vertex |
| |
| No_Vertex : Vertex_Id; |
| -- An indicator for a nonexistent vertex |
| |
| with function Hash_Vertex (V : Vertex_Id) return Bucket_Range_Type; |
| -- Map vertex V into the range of buckets |
| |
| with function Same_Vertex |
| (Left : Vertex_Id; |
| Right : Vertex_Id) return Boolean; |
| -- Compare vertex Left to vertex Right for identity |
| |
| ----------- |
| -- Edges -- |
| ----------- |
| |
| type Edge_Id is private; |
| -- The handle of an edge |
| |
| No_Edge : Edge_Id; |
| -- An indicator for a nonexistent edge |
| |
| with function Hash_Edge (E : Edge_Id) return Bucket_Range_Type; |
| -- Map edge E into the range of buckets |
| |
| with function Same_Edge |
| (Left : Edge_Id; |
| Right : Edge_Id) return Boolean; |
| -- Compare edge Left to edge Right for identity |
| |
| package Directed_Graphs is |
| |
| -- The following exceptions are raised when an attempt is made to add |
| -- the same edge or vertex in a graph. |
| |
| Duplicate_Edge : exception; |
| Duplicate_Vertex : exception; |
| |
| -- The following exceptions are raised when an attempt is made to delete |
| -- or reference a nonexistent component, edge, or vertex in a graph. |
| |
| Missing_Component : exception; |
| Missing_Edge : exception; |
| Missing_Vertex : exception; |
| |
| ---------------------- |
| -- Graph operations -- |
| ---------------------- |
| |
| -- The following type denotes a graph handle. Each instance must be |
| -- created using routine Create. |
| |
| type Directed_Graph is private; |
| Nil : constant Directed_Graph; |
| |
| procedure Add_Edge |
| (G : Directed_Graph; |
| E : Edge_Id; |
| Source : Vertex_Id; |
| Destination : Vertex_Id); |
| -- Add edge E to graph G which links vertex source Source and desination |
| -- vertex Destination. The edge is "owned" by vertex Source. This action |
| -- raises the following exceptions: |
| -- |
| -- * Duplicate_Edge, when the edge is already present in the graph |
| -- |
| -- * Iterated, when the graph has an outstanding edge iterator |
| -- |
| -- * Missing_Vertex, when either the source or desination are not |
| -- present in the graph. |
| |
| procedure Add_Vertex |
| (G : Directed_Graph; |
| V : Vertex_Id); |
| -- Add vertex V to graph G. This action raises the following exceptions: |
| -- |
| -- * Duplicate_Vertex, when the vertex is already present in the graph |
| -- |
| -- * Iterated, when the graph has an outstanding vertex iterator |
| |
| function Component |
| (G : Directed_Graph; |
| V : Vertex_Id) return Component_Id; |
| -- Obtain the component where vertex V of graph G resides. This action |
| -- raises the following exceptions: |
| -- |
| -- * Missing_Vertex, when the vertex is not present in the graph |
| |
| function Contains_Component |
| (G : Directed_Graph; |
| Comp : Component_Id) return Boolean; |
| -- Determine whether graph G contains component Comp |
| |
| function Contains_Edge |
| (G : Directed_Graph; |
| E : Edge_Id) return Boolean; |
| -- Determine whether graph G contains edge E |
| |
| function Contains_Vertex |
| (G : Directed_Graph; |
| V : Vertex_Id) return Boolean; |
| -- Determine whether graph G contains vertex V |
| |
| function Create |
| (Initial_Vertices : Positive; |
| Initial_Edges : Positive) return Directed_Graph; |
| -- Create a new graph with vertex capacity Initial_Vertices and edge |
| -- capacity Initial_Edges. This routine must be called at the start of |
| -- a graph's lifetime. |
| |
| procedure Delete_Edge |
| (G : Directed_Graph; |
| E : Edge_Id); |
| -- Delete edge E from graph G. This action raises these exceptions: |
| -- |
| -- * Iterated, when the graph has an outstanding edge iterator |
| -- |
| -- * Missing_Edge, when the edge is not present in the graph |
| -- |
| -- * Missing_Vertex, when the source vertex that "owns" the edge is |
| -- not present in the graph. |
| |
| function Destination_Vertex |
| (G : Directed_Graph; |
| E : Edge_Id) return Vertex_Id; |
| -- Obtain the destination vertex of edge E of graph G. This action |
| -- raises the following exceptions: |
| -- |
| -- * Missing_Edge, when the edge is not present in the graph |
| |
| procedure Destroy (G : in out Directed_Graph); |
| -- Destroy the contents of graph G, rendering it unusable. This routine |
| -- must be called at the end of a graph's lifetime. This action raises |
| -- the following exceptions: |
| -- |
| -- * Iterated, if the graph has any outstanding iterator |
| |
| procedure Find_Components (G : Directed_Graph); |
| -- Find all components of graph G. This action raises the following |
| -- exceptions: |
| -- |
| -- * Iterated, when the components or vertices of the graph have an |
| -- outstanding iterator. |
| |
| function Is_Empty (G : Directed_Graph) return Boolean; |
| -- Determine whether graph G is empty |
| |
| function Number_Of_Component_Vertices |
| (G : Directed_Graph; |
| Comp : Component_Id) return Natural; |
| -- Obtain the total number of vertices of component Comp of graph G |
| |
| function Number_Of_Components (G : Directed_Graph) return Natural; |
| -- Obtain the total number of components of graph G |
| |
| function Number_Of_Edges (G : Directed_Graph) return Natural; |
| -- Obtain the total number of edges of graph G |
| |
| function Number_Of_Outgoing_Edges |
| (G : Directed_Graph; |
| V : Vertex_Id) return Natural; |
| -- Obtain the total number of outgoing edges of vertex V of graph G |
| |
| function Number_Of_Vertices (G : Directed_Graph) return Natural; |
| -- Obtain the total number of vertices of graph G |
| |
| function Present (G : Directed_Graph) return Boolean; |
| -- Determine whether graph G exists |
| |
| function Source_Vertex |
| (G : Directed_Graph; |
| E : Edge_Id) return Vertex_Id; |
| -- Obtain the source vertex that "owns" edge E of graph G. This action |
| -- raises the following exceptions: |
| -- |
| -- * Missing_Edge, when the edge is not present in the graph |
| |
| ------------------------- |
| -- Iterator operations -- |
| ------------------------- |
| |
| -- The following types represent iterators over various attributes of a |
| -- graph. Each iterator locks all mutation operations of its associated |
| -- attribute, and unlocks them once it is exhausted. The iterators must |
| -- be used with the following pattern: |
| -- |
| -- Iter : Iterate_XXX (Graph); |
| -- while Has_Next (Iter) loop |
| -- Next (Iter, Element); |
| -- end loop; |
| -- |
| -- It is possible to advance the iterators by using Next only, however |
| -- this risks raising Iterator_Exhausted. |
| |
| -- The following type represents an iterator over all edges of a graph |
| |
| type All_Edge_Iterator is private; |
| |
| function Has_Next (Iter : All_Edge_Iterator) return Boolean; |
| -- Determine whether iterator Iter has more edges to examine |
| |
| function Iterate_All_Edges (G : Directed_Graph) return All_Edge_Iterator; |
| -- Obtain an iterator over all edges of graph G |
| |
| procedure Next |
| (Iter : in out All_Edge_Iterator; |
| E : out Edge_Id); |
| -- Return the current edge referenced by iterator Iter and advance to |
| -- the next available edge. This action raises the following exceptions: |
| -- |
| -- * Iterator_Exhausted, when the iterator has been exhausted and |
| -- further attempts are made to advance it. |
| |
| -- The following type represents an iterator over all vertices of a |
| -- graph. |
| |
| type All_Vertex_Iterator is private; |
| |
| function Has_Next (Iter : All_Vertex_Iterator) return Boolean; |
| -- Determine whether iterator Iter has more vertices to examine |
| |
| function Iterate_All_Vertices |
| (G : Directed_Graph) return All_Vertex_Iterator; |
| -- Obtain an iterator over all vertices of graph G |
| |
| procedure Next |
| (Iter : in out All_Vertex_Iterator; |
| V : out Vertex_Id); |
| -- Return the current vertex referenced by iterator Iter and advance |
| -- to the next available vertex. This action raises the following |
| -- exceptions: |
| -- |
| -- * Iterator_Exhausted, when the iterator has been exhausted and |
| -- further attempts are made to advance it. |
| |
| -- The following type represents an iterator over all components of a |
| -- graph. |
| |
| type Component_Iterator is private; |
| |
| function Has_Next (Iter : Component_Iterator) return Boolean; |
| -- Determine whether iterator Iter has more components to examine |
| |
| function Iterate_Components |
| (G : Directed_Graph) return Component_Iterator; |
| -- Obtain an iterator over all components of graph G |
| |
| procedure Next |
| (Iter : in out Component_Iterator; |
| Comp : out Component_Id); |
| -- Return the current component referenced by iterator Iter and advance |
| -- to the next component. This action raises the following exceptions: |
| -- |
| -- * Iterator_Exhausted, when the iterator has been exhausted and |
| -- further attempts are made to advance it. |
| |
| -- The following type prepresents an iterator over all vertices of a |
| -- component. |
| |
| type Component_Vertex_Iterator is private; |
| |
| function Has_Next (Iter : Component_Vertex_Iterator) return Boolean; |
| -- Determine whether iterator Iter has more vertices to examine |
| |
| function Iterate_Component_Vertices |
| (G : Directed_Graph; |
| Comp : Component_Id) return Component_Vertex_Iterator; |
| -- Obtain an iterator over all vertices that comprise component Comp of |
| -- graph G. |
| |
| procedure Next |
| (Iter : in out Component_Vertex_Iterator; |
| V : out Vertex_Id); |
| -- Return the current vertex referenced by iterator Iter and advance to |
| -- the next vertex. This action raises the following exceptions: |
| -- |
| -- * Iterator_Exhausted, when the iterator has been exhausted and |
| -- further attempts are made to advance it. |
| |
| -- The following type represents an iterator over all outgoing edges of |
| -- a vertex. |
| |
| type Outgoing_Edge_Iterator is private; |
| |
| function Has_Next (Iter : Outgoing_Edge_Iterator) return Boolean; |
| -- Determine whether iterator Iter has more outgoing edges to examine |
| |
| function Iterate_Outgoing_Edges |
| (G : Directed_Graph; |
| V : Vertex_Id) return Outgoing_Edge_Iterator; |
| -- Obtain an iterator over all the outgoing edges "owned" by vertex V of |
| -- graph G. |
| |
| procedure Next |
| (Iter : in out Outgoing_Edge_Iterator; |
| E : out Edge_Id); |
| -- Return the current outgoing edge referenced by iterator Iter and |
| -- advance to the next available outgoing edge. This action raises the |
| -- following exceptions: |
| -- |
| -- * Iterator_Exhausted, when the iterator has been exhausted and |
| -- further attempts are made to advance it. |
| |
| private |
| pragma Unreferenced (No_Edge); |
| |
| -------------- |
| -- Edge_Map -- |
| -------------- |
| |
| type Edge_Attributes is record |
| Destination : Vertex_Id := No_Vertex; |
| -- The target of a directed edge |
| |
| Source : Vertex_Id := No_Vertex; |
| -- The origin of a directed edge. The source vertex "owns" the edge. |
| end record; |
| |
| No_Edge_Attributes : constant Edge_Attributes := |
| (Destination => No_Vertex, |
| Source => No_Vertex); |
| |
| procedure Destroy_Edge_Attributes (Attrs : in out Edge_Attributes); |
| -- Destroy the contents of attributes Attrs |
| |
| package Edge_Map is new Dynamic_Hash_Tables |
| (Key_Type => Edge_Id, |
| Value_Type => Edge_Attributes, |
| No_Value => No_Edge_Attributes, |
| Expansion_Threshold => 1.5, |
| Expansion_Factor => 2, |
| Compression_Threshold => 0.3, |
| Compression_Factor => 2, |
| "=" => Same_Edge, |
| Destroy_Value => Destroy_Edge_Attributes, |
| Hash => Hash_Edge); |
| |
| -------------- |
| -- Edge_Set -- |
| -------------- |
| |
| package Edge_Set is new Membership_Sets |
| (Element_Type => Edge_Id, |
| "=" => "=", |
| Hash => Hash_Edge); |
| |
| ----------------- |
| -- Vertex_List -- |
| ----------------- |
| |
| procedure Destroy_Vertex (V : in out Vertex_Id); |
| -- Destroy the contents of a vertex |
| |
| package Vertex_List is new Doubly_Linked_Lists |
| (Element_Type => Vertex_Id, |
| "=" => Same_Vertex, |
| Destroy_Element => Destroy_Vertex); |
| |
| ---------------- |
| -- Vertex_Map -- |
| ---------------- |
| |
| type Vertex_Attributes is record |
| Component : Component_Id := No_Component; |
| -- The component where a vertex lives |
| |
| Outgoing_Edges : Edge_Set.Membership_Set := Edge_Set.Nil; |
| -- The set of edges that extend out from a vertex |
| end record; |
| |
| No_Vertex_Attributes : constant Vertex_Attributes := |
| (Component => No_Component, |
| Outgoing_Edges => Edge_Set.Nil); |
| |
| procedure Destroy_Vertex_Attributes (Attrs : in out Vertex_Attributes); |
| -- Destroy the contents of attributes Attrs |
| |
| package Vertex_Map is new Dynamic_Hash_Tables |
| (Key_Type => Vertex_Id, |
| Value_Type => Vertex_Attributes, |
| No_Value => No_Vertex_Attributes, |
| Expansion_Threshold => 1.5, |
| Expansion_Factor => 2, |
| Compression_Threshold => 0.3, |
| Compression_Factor => 2, |
| "=" => Same_Vertex, |
| Destroy_Value => Destroy_Vertex_Attributes, |
| Hash => Hash_Vertex); |
| |
| ------------------- |
| -- Component_Map -- |
| ------------------- |
| |
| type Component_Attributes is record |
| Vertices : Vertex_List.Doubly_Linked_List := Vertex_List.Nil; |
| end record; |
| |
| No_Component_Attributes : constant Component_Attributes := |
| (Vertices => Vertex_List.Nil); |
| |
| procedure Destroy_Component_Attributes |
| (Attrs : in out Component_Attributes); |
| -- Destroy the contents of attributes Attrs |
| |
| package Component_Map is new Dynamic_Hash_Tables |
| (Key_Type => Component_Id, |
| Value_Type => Component_Attributes, |
| No_Value => No_Component_Attributes, |
| Expansion_Threshold => 1.5, |
| Expansion_Factor => 2, |
| Compression_Threshold => 0.3, |
| Compression_Factor => 2, |
| "=" => "=", |
| Destroy_Value => Destroy_Component_Attributes, |
| Hash => Hash_Component); |
| |
| ----------- |
| -- Graph -- |
| ----------- |
| |
| type Directed_Graph_Attributes is record |
| All_Edges : Edge_Map.Dynamic_Hash_Table := Edge_Map.Nil; |
| -- The map of edge -> edge attributes for all edges in the graph |
| |
| All_Vertices : Vertex_Map.Dynamic_Hash_Table := Vertex_Map.Nil; |
| -- The map of vertex -> vertex attributes for all vertices in the |
| -- graph. |
| |
| Components : Component_Map.Dynamic_Hash_Table := Component_Map.Nil; |
| -- The map of component -> component attributes for all components |
| -- in the graph. |
| end record; |
| |
| type Directed_Graph is access Directed_Graph_Attributes; |
| Nil : constant Directed_Graph := null; |
| |
| --------------- |
| -- Iterators -- |
| --------------- |
| |
| type All_Edge_Iterator is new Edge_Map.Iterator; |
| type All_Vertex_Iterator is new Vertex_Map.Iterator; |
| type Component_Iterator is new Component_Map.Iterator; |
| type Component_Vertex_Iterator is new Vertex_List.Iterator; |
| type Outgoing_Edge_Iterator is new Edge_Set.Iterator; |
| end Directed_Graphs; |
| |
| private |
| First_Component : constant Component_Id := No_Component + 1; |
| |
| end GNAT.Graphs; |
