Re: GCC 4.0 Ada.Containers Cursor danger.

["Matthew Heaney" <mheaney@on2.com>]

Dmitriy Anisimkov wrote:
>
> I would propose to have a Ada.Containers subset without cursors for
> safety reasons.

You are free to write Ada *programs* that don't use cursors, but that
is far different from proposing that the *library* not use cursors.


> Where the "windows" safer in C or in Ada ?

We are not debating here anything about the language proper.  We are
simply debating the choices in the design of the standard container
library.

Of course it would be possible to design the library such that cursor
misuse is required to be detected.  But not without incurring a
substantial time and space penalty.

The solution in your case is for *you* to either not use cursors, or to
implement a higher-level abstraction that either prevents or detects
cursor misuse.  Something like:

package Container_Types is
   type Container_Type is limited private;
   type Cursor is private;
   function Find (C : CT; E : ET) return Cursor;
...
private
   type Node_Type is record
      E : ET;
      Cursor_Count : Natural := 0;
   end record;

   package Rep_Types is
     new Ada.Containers.Ordered_Maps (KT, Node_Type, ...);
     --whatever container suits your needs
...
   type Container_Type is
      new Limited_Controlled with record
         H : Handle_Type (Container_Type'Access); -- rosen trick
         Rep : Rep_Types.Map;
         Cursor_Count : Natural := 0;
      end record;
...
   type Cursor is
      new Controlled with record
        Rep : Rep_Types.Cursor;
      end record;
...
end Container_Types;

Now you can record the fact that there are extant cursors:

  function Find (C : CT; E : ET) return Cursor is
    Result : Rep_Types.Cursor := Rep_Types.Find (C, E);
  begin
    if not Has_Element (Result) then
       return Cursor'(Controlled with Rep_Types.No_Element);
    end if;

    declare
       procedure Inc_Count (Node : in out Node_Type) is
       begin
          Node.Cursor_Count := Node.Cursor_Count + 1;
       end;
   begin
       Update_Element (Result, Inc_Count'Access);
   end;

   C.H.Cursor_Count := C.H.Cursor_Count + 1;

   return (Controlled with Result);
  end Find;

Now when you attempt to Delete an element (as you did in your earlier
example), you can inspect the node's cursor count and take appropriate
action.

In the Finalize operation of your Container_Type, you can detect
whether there exist extant cursors, and if so take appropriate action.

Of course, all these checks have a time and space cost.  If you're
willing to pay that cost, then by all means implement your container
abstractions as above.  The standard container library is flexible and
efficient enough that it allows you to implement any other (less
flexible and less efficient but putatively safer) abstraction.

-Matt