Re: OO Style with Ada Containers

[Matthew Heaney <mheaney@on2.com>]

On Nov 19, 4:29 pm, Maciej Sobczak <see.my.homep...@gmail.com> wrote:
> Then, considering the fact that elements in Ada.Containers cannot be
> modified without naming the container in addition to providing the
> cursor/iterator and this is different from both STL and Java (STL
> dereferences iterators to l-values and Java is reference-oriented
> anyway - in both cases iterators can be used to query as well as to
> update elements), then I would say that Ada.Containers has a similar
> "distance" to STL as it has to java.util.

Yes, by design the container has to be named in any operation that
modifies its elements, but this does *not* imply that the generic
algorithm itself has to know anything about containers:

generic
  type Cursor is private;
  type ET is private;
  with procedure Add (C : Cursor; E : ET) is <>;
  with function Next (C : Cursor) return Cursor is <>;
  with function Has_Element (C : Cursor) return Boolean is <>;
procedure Generic_Algorithm
  (C : Cursor;
   E : ET);

You can see here that the algorithm does not name a container.  The
body looks like this:

procedure Generic_Algorithm
  (C : Cursor;
   E : ET)
is
   CC : Cursor := C;
begin
   while Has_Element (CC) loop
      Add (CC, E);
      CC := Next (CC);
   end loop;
end Generic_Algorithm;

Now let's instantiate using our integer vector container:

procedure Op (V : in out Integer_Vectors.Vector) is
  procedure Add (C : Cursor; I : Integer) is
     procedure Process (E : in out Integer) is
     begin
        E := E + I;
     end Process;
  begin
     V.Update_Element (C, Process'Access);
  end Add;

  procedure Algorithm is
    new Generic_Algorithm (Cursor, Integer);
begin
  Algorithm (V.First);
end Op;

The point of this example is to demonstrate that Ada provides
mechanisms (locally-declared subprograms) to bind the algorithm to the
container.


> I see (except for Indefinite_XXX, which are Ada-specific), but that
> still does not convince me.

Well, I'm in a very good position to know whether the Ada container
library was designed with the STL in mind!


> C++ does not currently have any hash
> containers (the "original" STL and some third-party implementations
> might have them, though)

No, hashed forms were added to the latest version of the C++ standard.


> > > Do you by any chance find
> > > something in C++ that is worth imitating? :-)
>
> > Yes, of course: the STL.
>
> What about IOStreams?
>
> Hey, we can even mix these two:
>
> copy(my_vector.begin(),
>      my_vector.end(),
>      ostream_iterator<int>(cout, " "));
>
> ;-)

Oh, yes, I should have mentioned the iostream library.  In Ada you
could say:

generic
  type ET is limited private;
  with procedure Process (E : ET) is <>;
  ...
procedure Generic_Copy (...);

procedure Op (V : Integer_Vectors.Vector) is
  procedure Process (E : Integer) is
  begin
     Integer_Text_IO.Put (E, Width => 0);
     Put (' ');
  end;
  procedure Copy is
    new Generic_Copy (Integer, Process);
begin
  Copy (V.First);
end Op;

;^)


> > A generic algorithm in Ada would look something like:
>
> You mean: read-only algorithm.

No, I meant "algorithm"; see the example above.


> What about modifying algorithms?
> Ada.Containers.Vectors.Generic_Sorting shows the problem.

There is no problem.  To bind a generic algorithm to a container
object (that needs to be modified), use a locally-declared subprogram.


> I like it. Really. It is not possible to do it in C++, the new classes
> have to be composed with replaced operations.

It shows that it can be done -- just differently from C++.  Vive la
difference!

-Matt