Re: discriminant questions

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 19.09.11 19:49, ytomino wrote:

> -- "count" algorithm with Ada 2005 version
> generic
>     type Element_Type (<>) is private;
>     type Cursor is private;
>     type Container is private;
>     package Iterator_Interfaces is
>        new Ada.Iterator_Interfaces (Cursor, others =>  <>);
>     with function Iterate (C : Container)
>        return Iterator_Interfaces.Forward_Iterator'Class;
>     type Constant_Reference_Type (
>        Element : not null access constant Element_Type) with private;
> <- *B*
>     with function Constant_Reference (C : Container; P : Cursor)
>        return Constant_Reference_Type;
> procedure Generic_Count (C : Container; Value : Element_Type) return
> Count_Type;
>
> There is no way to use a instance of Vectors.Constant_Reference_Type
> as *B*.

(I have taken the liberty of choosing name `Iterator` for
formal function `Iterate`, since a different `Iterate` is
already taken by the container packages.)

function Generic_Count
   (C : Container;
    Value : Element_Type)
    return Ada.Containers.Count_Type
is
    use type Ada.Containers.Count_Type;

    Sum : Ada.Containers.Count_Type := 0;
    -- overall result


    procedure Use_CRefT (Wrap : Constant_Reference_Type) is
    begin
       if Wrap.Element.all = Value then
          Sum := Sum + 1;
       end if;
    end Use_CRefT;

    procedure Search (Position : Cursor) is
       Element_To_Be_Pointed_At : Constant_Reference_Type
           renames Constant_Reference (C, Position);
    begin
       Use_CRefT(Element_To_Be_Pointed_At);
    end Search;

    Star : Iterator_Interfaces.Forward_Iterator'Class := Iterator (C);
    Pos : Cursor;

begin

    Pos := Iterator_Interfaces.First (Star);
    while Pos /= Iterator_Interfaces.No_Element loop
       Search (Pos);
       Pos := Iterator_Interfaces.Next (Star, Pos);
    end loop;

    return Sum;
end Generic_Count;


I think, though, that Query_Element will obviate the need for the
wrapping pointer types; not sure I understand why you want them.
Is this influenced by a 1:1 transport of C++ STL algorithms?

I wonder whether the C++ STL would be different if C++ could use
proper nesting or in case it had drawn more attention to function
objects.