Return to generic_lists_of_vectors.ads CVS log

Up to [local] / OpenXM_contrib / PHC / Ada / Math_Lib / Supports

Annotation of OpenXM_contrib/PHC/Ada/Math_Lib/Supports/generic_lists_of_vectors.ads, Revision 1.1.1.1

1.1       maekawa     1: with Abstract_Ring;
                      2: with Generic_Vectors;
                      3: with Generic_VecVecs;
                      4: with Generic_Lists;
                      5:
                      6: generic
                      7:
                      8:   with package Ring is new Abstract_Ring(<>);
                      9:   with package Vectors is new Generic_Vectors(Ring);
                     10:   with package VecVecs is new Generic_VecVecs(Ring,Vectors);
                     11:
                     12: package Generic_Lists_of_Vectors is
                     13:
                     14: -- DESCRIPTION :
                     15: --   An implementation of lists of links to vectors.
                     16:
                     17:   use Vectors,VecVecs;
                     18:
                     19: -- DATA STRUCTURE : a list of pointers to vectors
                     20:
                     21:   package Vector_Lists is new Generic_Lists(Link_to_Vector);
                     22:   type List is new Vector_Lists.List;
                     23:
                     24: -- CREATORS :
                     25:
                     26:   function Deep_Create    ( v : VecVec ) return List;
                     27:   function Shallow_Create ( v : VecVec ) return List;
                     28:
                     29:   function Deep_Create    ( l : List ) return VecVec;
                     30:   function Shallow_Create ( l : List ) return VecVec;
                     31:
                     32:   -- DESCRIPTION :
                     33:   --   l := Create(v) equals v := Create(l).
                     34:   --   There is no sharing of pointers with a deep Create.
                     35:   --   With a shallow Create, both structure share the pointers.
                     36:
                     37: -- COMPARISON and COPYING :
                     38:
                     39:   procedure Copy ( l1 : in List; l2 : in out List );
                     40:
                     41:   -- DESCRIPTION :
                     42:   --   After Copy(l1,l2), Equal(l1,l2) holds.
                     43:   --   Of course, this is a deep copy, a shallow copy is given by l2 := l1.
                     44:
                     45:   function Equal ( l1,l2 : List ) return boolean;
                     46:
                     47:   -- DESCRIPTION :
                     48:   --   Returns true if both lists have the same vectors, false otherwise.
                     49:
                     50: -- SELECTORS :
                     51:
                     52:   function Is_In ( l : List; v : Vector ) return boolean;
                     53:   function Is_In ( l : List; v : Link_to_Vector ) return boolean;
                     54:
                     55:   -- DESCRIPTION :
                     56:   --   Returns true if the vector belongs to l, false otherwise.
                     57:
                     58:   function Sub_List ( l1,l2 : List ) return boolean;
                     59:
                     60:   -- DESCRIPTION :
                     61:   --   Returns true if all elements in l1 occur in l2, false otherwise.
                     62:
                     63: -- CONSTRUCTORS :
                     64:
                     65:   procedure Append ( first,last : in out List; v : in Vector );
                     66:
                     67:   -- DESCRIPTION :
                     68:   --   The vector will be appended to the list first,
                     69:   --   last is a pointer to the last element of the list first.
                     70:
                     71:   procedure Append_Diff ( first,last : in out List; v : in Vector );
                     72:   procedure Append_Diff ( first,last : in out List; v : in Link_to_Vector );
                     73:
                     74:   -- DESCRIPTION :
                     75:   --   Only when v does not already belong to first, v will be added.
                     76:
                     77:   procedure Deep_Concat    ( first,last : in out List; l : in List );
                     78:   procedure Shallow_Concat ( first,last : in out List; l : in List );
                     79:
                     80:   -- DESCRIPTION :
                     81:   --   The list l will be concatenated to the list first,
                     82:   --   last is a pointer to the last element of the list first.
                     83:   --   With a deep concatenation, no pointers are shared.
                     84:
                     85:   procedure Deep_Concat_Diff    ( first,last : in out List; l : in List );
                     86:   procedure Shallow_Concat_Diff ( first,last : in out List; l : in List );
                     87:
                     88:   -- DESCRIPTION :
                     89:   --   Only those vectors of l will be concatenated that are not already
                     90:   --   in the list first.
                     91:   --   With a deep concatenation, no pointers are shared.
                     92:
                     93:   procedure Remove ( l : in out List; x : in Vector );
                     94:   procedure Remove ( l : in out List; x : in Link_to_Vector );
                     95:
                     96:   -- DESCRIPTION :
                     97:   --   Removes the point x from the list l.
                     98:
                     99:   procedure Swap_to_Front ( l : in out List; x : in Vector );
                    100:   procedure Swap_to_Front ( l : in out List; x : in Link_to_Vector );
                    101:
                    102:   -- DESCRIPTION :
                    103:   --   The point x belongs to the list l,
                    104:   --   Its content will be place in front of l and the first element
                    105:   --   of l will be swapped to the place of x.
                    106:
                    107: -- DESTRUCTORS :
                    108:
                    109:   procedure Deep_Clear    ( l : in out List );
                    110:   procedure Shallow_Clear ( l : in out List );
                    111:
                    112:   -- DESCRIPTION :
                    113:   --   Frees all allocated memory space.
                    114:   --   A deep clear deallocates also the points to the integer vectors,
                    115:   --   while a shallow clear only removes the list structure.
                    116:
                    117: end Generic_Lists_of_Vectors;