Re: OO Style with Ada Containers

[Matthew Heaney <matthewjheaney@earthlink.net>]

Ludovic Brenta <ludovic@ludovic-brenta.org> writes:

Instead of this:

   type Word_Counter is
      Word : Ada.Strings.Unbounded.Unbounded_String;
      Count : Natural;
   end Word_Counter;

I would have declared it something like this:

   type Word_Counter (Length : Positive) is record
      Word  : String (1 .. Length);
      Count : Natural;
   end record;

and then used the indefinite form of the (hashed) set.


>    Current_Word := Get_Next_Word;
>    Position := Counters.Find (Current_Word);
>    if Position = Word_Counter_Hashed_Sets.No_Element then
>       Counters.Insert (New_Item => (Word => Current_Word, Count => 1));
>    else
>       declare
>          E : constant Word_Counter := Counters.Element (Position);
>       begin
>          Counters.Replace_Element
>             (Position => Position,
>              New_Item => (Word => E.Word, -- [1]
>                           Counter => E.Counter + 1));
>       end;
>    end if;


Right, but this suffers from the same problem as in the original example (Find
duplicates the work done by Insert).


> (does [1] duplicate E.Word each time we increment the counter?  

Yes, because this replaces the entire element; the old element will get
destroyed, and a new element created.


> If so,
> consider using
> Ada.Containers.Hashed_Sets.Generic_Keys.Update_Element_Preserving_Keys).

Well, almost.  That does indeed allow you to modify an element in-place, but it
must copy the key in order to verify that you didn't modify it, so it doesn't
really solve the problem.