Re: Ada.Containers.Vectors - querying multiple elements

[Jeffrey Carter <spam@spam.com>]

Georg Bauhaus wrote:

> Duncan Sands wrote:
> 
>>    procedure Query_Elements
>>        (Container   : in Vector;
>>         First_Index : in Index_Type;
>>         Last_Index  : in Extended_Index;
>>         Process   : not null access procedure (Elements : in 
>> Element_Array));
> 
> 
> Couldn't you use Cursors,

IMNSHO, a unbounded-array abstraction doesn't need such operations, nor 
cursors. One should use it in a manner very similar to an array:

for I in Index'First .. Last (Container) loop
    -- operate on Get (Container, I)
end loop;

During early discussions on AI-302 I implemented an unbounded-array 
package based on Ada.Strings.Unbounded, from the point of view that the 
basic operations in Unbounded are an instantiation of the 
unbounded-array with Character, Positive, and String. Here's the spec, 
if anyone's interested (lines may wrap):

with Ada.Finalization;
with System;
generic -- Unbounded_Arrays
    type Index is (<>);
    type Element is private;
    type Fixed is array (Index range <>) of Element;

    with function "=" (Left : Element; Right : Element) return Boolean 
is <>;
package Unbounded_Arrays is
    pragma Preelaborate;

    type Unbounded_Array is private;
    -- Initial value: null, equal to Null_Unbounded_Array, Length = 0.
    --
    -- An Unbounded_Array is similar to a Fixed. It has a lower bound of 
Index'First,
    -- and an upper bound that can vary dynamically up to Index'Last.

    Null_Unbounded_Array : constant Unbounded_Array;

    -- Conversions

    function To_Unbounded (Source : Fixed) return Unbounded_Array;
    function "+" (Source : Fixed) return Unbounded_Array renames 
To_Unbounded;
    -- Converts Source to an Unbounded_Array.

    function To_Fixed (Source : Unbounded_Array) return Fixed;
    function "+" (Source : Unbounded_Array) return Fixed renames To_Fixed;
    -- Converts Source to a Fixed. If Source is null and there is no 
representation
    -- for a null Fixed, raises Constraint_Error.

    -- Size and index information

    Invalid_Index : exception;
    -- Raised by operations dealing with Index when the Index is invalid.

    function Last (Source : Unbounded_Array) return Index;
    -- Returns the Index of the last position occupied in Source.
    -- If Source is null, returns Index'First.
    -- Similar to the array operation Source'Last.

    type Count is mod System.Max_Binary_Modulus;

    function Length (Source : Unbounded_Array) return Count;
    -- Returns the number of occupied positions in Source.
    -- Similar to the array operation Source'Length.
    -- If the result is > Count'Last, raises Constraint_Error.

    -- Access to Elements

    function Get (From : Unbounded_Array; Location : Index) return Element;
    -- Returns the Element stored in From at position Location.
    -- Similar to the array operation From (Location).
    --
    -- Precondition:
    --    Length (From) > 0 and
    --    Location in Index'First .. Last (From)     raises 
Invalid_Index if violated

    procedure Put (Into : in out Unbounded_Array; Location : in Index; 
Item : in Element);
    -- Changes the Element stored in Into at position Location to be Item.
    -- Similar to the array operation Into (Location) := Item.
    --
    -- Precondition:
    --    Length (Into) > 0 and
    --    Location in Index'First .. Last (Into)     raises 
Invalid_Index if violated
    --
    -- Postcondition:
    --    Get (Into, Location) = Item

    function Slice (From : Unbounded_Array; Low : Index; High : Index) 
return Fixed;
    function Slice (From : Unbounded_Array; Low : Index; High : Index) 
return Unbounded_Array;
    -- Return the slice of From with bounds Low .. High. Similar to the 
array operation
    -- From (Low .. High).
    -- The version that returns a Fixed returns a value with bounds of 
Low .. High.
    -- The version that returns an Unbounded_Array follows the 
specification of the type:
    -- the lower bound is always Index'First.
    --
    -- Precondition:
    --    Low > High                          or
    --    (Length (From) > 0                  and
    --     Low  in Index'First .. Last (From) and
    --     High in Index'First .. Last (From) )       raises 
Invalid_Index if violated

    procedure Replace_Slice (Into : in out Unbounded_Array; Low : Index; 
High : Index; Replacement : Fixed);
    procedure Replace_Slice (Into : in out Unbounded_Array; Low : Index; 
High : Index; Replacement : Unbounded_Array);
    -- Replaces the slice of Into with bounds Low .. High with Replacement.
    -- Similar to the array operation Into (Low .. High) := Replacement.
    --
    -- Preconditions:
    --    (Low > High and [Replacement'Length or Length (Replacement)] = 
0) or
    --    (Length (Into) > 0                  and
    --     Low  in Index'First .. Last (Into) and
    --     High in Index'First .. Last (Into) )       raises 
Invalid_Index if violated
    --
    --    [Replacement'Length or Length (Replacement)] =
    --    Length (Slice (Into, Low, High) )           raises 
Constraint_Error if violated
    --
    -- Postcondition:
    --    Slice (Into, Low, High) = Replacement

    -- Concatenation

    procedure Append (Onto : in out Unbounded_Array; Item : in Element);
    procedure Append (Onto : in out Unbounded_Array; Item : in Fixed);
    procedure Append (Onto : in out Unbounded_Array; Item : in 
Unbounded_Array);
    -- Equivalent to Onto := Onto & Item.

    function "&" (Left : Unbounded_Array; Right : Unbounded_Array) 
return Unbounded_Array;
    function "&" (Left : Unbounded_Array; Right : Fixed) 
return Unbounded_Array;
    function "&" (Left : Fixed;           Right : Unbounded_Array) 
return Unbounded_Array;
    function "&" (Left : Unbounded_Array; Right : Element) 
return Unbounded_Array;
    function "&" (Left : Element;         Right : Unbounded_Array) 
return Unbounded_Array;
    -- Similar to the equivalent array operations.

    -- Equality

    function "=" (Left : Unbounded_Array; Right : Unbounded_Array) 
return Boolean;
    function "=" (Left : Unbounded_Array; Right : Fixed) 
return Boolean;
    function "=" (Left : Fixed;           Right : Unbounded_Array) 
return Boolean;
    -- Returns True if Left and Right represent the same array value; 
False otherwise
private -- Unbounded_Arrays
    -- Not specified by the language ...
end Unbounded_Arrays;

Unlike the Vector container that will be part of Ada 0X, this has no 
restrictions on the Index subtype. Any discrete type is acceptable.

-- 
Jeff Carter
"What I wouldn't give for a large sock with horse manure in it."
Annie Hall
42