Generic package: Ada.Containers.Indefinite

Generic package: Ada.Containers.Indefinite_Vectors

Dependencies

with Ada.Finalization;
with Ada.Streams;

Description

AI-302 Reference Implementation

The AI-302 Reference Implementation is free software; you can redistribute it and/or modify it under terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. Charles 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 distributed with Charles; see file COPYING.TXT. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

As a special exception, if other files instantiate generics from this unit, or you link this unit with other files to produce an executable, this unit does not by itself cause the resulting executable to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the executable file might be covered by the GNU Public License.

The AI-302 Reference Implementation is maintained by Matthew J Heaney.

mailto:matthewjheaney@earthlink.net http://home.earthlink.net/~matthewjheaney/index.html

Header

generic

   type Index_Type is range <>;

   type Element_Type (<>) is private;

   with function "=" (Left, Right : Element_Type)
     return Boolean is <>;

package Ada.Containers.Indefinite_Vectors is

pragma Preelaborate (Indefinite_Vectors);

Type Summary

`Cursor`
Primitive Operations:	`Delete`, `Element`, `Find`, `First`, `Has_Element`, `Insert`, `Insert`, `Insert`, `Insert`, `Insert_Space`, `Last`, `Next`, `Next`, `Previous`, `Previous`, `Replace_Element`, `Reverse_Find`, `Swap`, `To_Cursor`, `To_Index`, `Update_Element`
`Iterate_Process`
`Reverse_Iterate_Process` derived from `Iterate_Process`
`Update_Element_Process`
`Vector`
Primitive Operations:	`"&"`, `"&"`, `"&"`, `"&"`, `"="`, `Append`, `Append`, `Assign`, `Capacity`, `Clear`, `Delete`, `Delete`, `Delete_First`, `Delete_Last`, `Element`, `Find`, `Find`, `First`, `First_Element`, `First_Index`, `Insert`, `Insert`, `Insert`, `Insert`, `Insert`, `Insert`, `Insert_Space`, `Insert_Space`, `Is_Empty`, `Is_In`, `Iterate`, `Last`, `Last_Element`, `Last_Index`, `Length`, `Move`, `Prepend`, `Prepend`, `Replace_Element`, `Reverse_Find`, `Reverse_Find`, `Reverse_Iterate`, `Set_Capacity`, `Set_Length`, `Swap`, `Swap`, `To_Cursor`, `To_Vector`, `To_Vector`, `Update_Element`

Constants and Named Numbers

Empty_Vector : constant Vector;

No_Element : constant Cursor;

Other Items:

pragma Assert (Index_Type'Base'First < Index_Type'First);

subtype Index_Subtype is Index_Type;

type Vector is tagged private;

type Cursor is private;

function To_Vector (Count : Count_Type) return Vector;

function To_Vector (New_Item : Element_Type;
                    Count    : Count_Type)
  return Vector;

function "&" (Left, Right : Vector) return Vector;

function "&" (Left  : Vector;
              Right : Element_Type) return Vector;

function "&" (Left  : Element_Type;
              Right : Vector) return Vector;

function "&" (Left, Right : Element_Type) return Vector;

function "=" (Left, Right : Vector) return Boolean;

function Capacity (Container : Vector) return Count_Type;

procedure Set_Capacity (Container : in out Vector;
                        Capacity  : in     Count_Type);

function Length (Container : Vector) return Count_Type;

function Is_Empty (Container : Vector) return Boolean;

procedure Clear (Container : in out Vector);

function To_Cursor (Container : Vector;
                    Index     : Index_Type'Base)
   return Cursor;

function To_Index (Position : Cursor) return Index_Type'Base;

function Element (Container : Vector;
                  Index     : Index_Type'Base)
   return Element_Type;

function Element (Position : Cursor) return Element_Type;

type Update_Element_Process is
  access procedure (Element : in out Element_Type);

procedure Update_Element
  (Container : in Vector;
   Index     : in Index_Type'Base;
   Process   :    Update_Element_Process);

Ada0Y


  not null access procedure (Element : in out Element_Type));

The best we can do in Ada95 is to generate a run-time error, so if Process is null a Program_Error is raised.

procedure Update_Element
  (Position : in Cursor;
   Process  :    Update_Element_Process);

Ada0Y


  not null access procedure (Element : in out Element_Type));

The best we can do in Ada95 is to generate a run-time error, so if Process is null a Program_Error is raised.

procedure Replace_Element (Container : in Vector;
                           Index     : in Index_Type'Base;
                           By        : in Element_Type);

procedure Replace_Element (Position : in Cursor;
                           By       : in Element_Type);

procedure Assign (Target : in out Vector;
                  Source : in     Vector);

procedure Move (Target : in out Vector;
                Source : in out Vector);

procedure Insert (Container : in out Vector;
                  Before    : in     Index_Type'Base;
                  New_Item  : in     Vector);

procedure Insert (Container : in out Vector;
                  Before    : in     Cursor;
                  New_Item  : in     Vector);

procedure Insert (Container : in out Vector;
                  Before    : in     Cursor;
                  New_Item  : in     Vector;
                  Position  :    out Cursor);

procedure Insert (Container : in out Vector;
                  Before    : in     Index_Type'Base;
                  New_Item  : in     Element_Type;
                  Count     : in     Count_Type := 1);

procedure Insert (Container : in out Vector;
                  Before    : in     Cursor;
                  New_Item  : in     Element_Type;
                  Count     : in     Count_Type := 1);

procedure Insert (Container : in out Vector;
                  Before    : in     Cursor;
                  New_Item  : in     Element_Type;
                  Position  :    out Cursor;
                  Count     : in     Count_Type := 1);

procedure Prepend (Container : in out Vector;
                   New_Item  : in     Vector);

procedure Prepend (Container : in out Vector;
                   New_Item  : in     Element_Type;
                   Count     : in     Count_Type := 1);

procedure Append (Container : in out Vector;
                  New_Item  : in     Vector);

procedure Append (Container : in out Vector;
                  New_Item  : in     Element_Type;
                  Count     : in     Count_Type := 1);

procedure Insert_Space (Container : in out Vector;
                        Before    : in     Index_Type'Base;
                        Count     : in     Count_Type := 1);

procedure Insert_Space (Container : in out Vector;
                        Before    : in     Cursor;
                        Position  :    out Cursor;
                        Count     : in     Count_Type := 1);

procedure Set_Length (Container : in out Vector;
                      Length    : in     Count_Type);

procedure Delete (Container : in out Vector;
                  Index     : in     Index_Type'Base;
                  Count     : in     Count_Type := 1);

procedure Delete (Container : in out Vector;
                  Position  : in out Cursor;
                  Count     : in     Count_Type := 1);

procedure Delete_First (Container : in out Vector;
                        Count     : in     Count_Type := 1);

procedure Delete_Last (Container : in out Vector;
                       Count     : in     Count_Type := 1);

function First_Index (Container : Vector) return Index_Type;

function First (Container : Vector) return Cursor;

function First_Element (Container : Vector) return Element_Type;

function Last_Index (Container : Vector) return Index_Type'Base;

function Last (Container : Vector) return Cursor;

function Last_Element (Container : Vector) return Element_Type;

procedure Swap (Container : in Vector;
                I, J      : in Index_Type'Base);

procedure Swap (Container : in Vector;
                I, J      : in Cursor);

generic
   with function "<" (Left, Right : Element_Type) return Boolean is <>;
procedure Generic_Sort (Container : in Vector);

function Find (Container : Vector;
               Item      : Element_Type;
               Index     : Index_Type'Base := Index_Type'First)
   return Index_Type'Base;

function Find (Container : Vector;
               Item      : Element_Type;
               Position  : Cursor := No_Element)
   return Cursor;

function Reverse_Find (Container : Vector;
                       Item      : Element_Type;
                       Index     : Index_Type'Base := Index_Type'Last)
   return Index_Type'Base;

function Reverse_Find (Container : Vector;
                       Item      : Element_Type;
                       Position  : Cursor := No_Element)
   return Cursor;

function Is_In (Item      : Element_Type;
                Container : Vector)
   return Boolean;

function Next (Position : Cursor) return Cursor;

function Previous (Position : Cursor) return Cursor;

procedure Next (Position : in out Cursor);

procedure Previous (Position : in out Cursor);

function Has_Element (Position : Cursor) return Boolean;

type Iterate_Process is
  access procedure (Position : in Cursor);

procedure Iterate
  (Container : in Vector;
   Process   :    Iterate_Process);

Ada0Y


  not null access procedure (Position : in Cursor));

The best we can do in Ada95 is to generate a run-time error, so if Process is null a Program_Error is raised.

type Reverse_Iterate_Process is
  new Iterate_Process;

procedure Reverse_Iterate
  (Container : in Vector;
   Process   :    Reverse_Iterate_Process);

Ada0Y


  not null access procedure (Position : in Cursor));

The best we can do in Ada95 is to generate a run-time error, so if Process is null a Program_Error is raised.

private

   --  Implementation-defined ...

end Ada.Containers.Indefinite_Vectors;