How does the () magic in the Ada.Containers work?

General
,
1

When using Ada.Containers you can do stuff like Container (Key) to access the elements. How does that actually work? What code is created? Which methods called? And most importantly: Can you do it in your own code or is that magic only available for standard library?

2

You can. See Ada RM 4.1.6.

1 Like
3

To give a bit more detail. There are two different aspects for handling this.

Constant_Indexing is used for scenarios where you are “reading” the indexed value. Variable_Indexing is used when you are “modifying” the indexed value.

Constant indexing is easier, so need to make a function with the general layout:

function Function_Name
   (Self  : Container_Type; 
    Index : Index_Type) 
    return Element_Type

OR

function Function_Name
   (Self  : aliased Container_Type;
    Index : Index_Type)
    return Constant_Reference_Type;  -- more on this type in a min

Then you can assign it to the Container type via the aspect:

type Container_Type is private
   with Constant_Indexing => Function_Name;

NOTE: Unlike most things in Ada, the declaration of Function_Name can come after this point. Ada has a special rule for finding the declaration after this point.

What is that Constant_Reference_Type? It is a special kind of discriminated record with the Implicit_Dereference aspect set. Here is a simple example but you can have more complex record types:

type Constant_Reference_Type
   (Element : not null access constant Element_Type)
is limited null record
   with Implicit_Dereference => Element;

This is essentially a wrapper around an access type that makes it “look” like the Element type when used in code. So if your declaration is:

type Constant_Reference_Type
   (Element : not null access constant Integer)
is limited null record
   with Implicit_Dereference => Element;

Then it would just look like an integer even though it is a record (in most cases) .

The tricky part though is that the above is technically unsafe as is. You can get into instances where you have an object of this record type, but the element in the container gets deallocated by some other code. So in practice you have to have some sort of logic for making sure the element cannot be deleted while this is available (usually via counts and controlled objects) . The containers in the standard library do this behind the scenes.

For variable indexing, you need similar but slightly different declarations:

type Container_Type is private
   with Variable_Indexing => Function_Name;

type Reference_Type
   (Element : not null access Integer) -- NOTE:  not access to constant
is limited null record
   with Implicit_Dereference => Element;

function Function_Name
   (Self  : aliased in out Container_Type;  -- NOTE: in out instead of in
    Index : Index_Type)
    return Reference_Type;

You can specify either one or both (though if you specify both, you may have to give different Function_Name names for each…don’t remember off hand).

If you look at the code for GNAT’s containers you can see some good examples.

3 Likes
4

Thanks. It’s sometimes difficult to find stuff.

So for read only access there is the simplified option but for read write you need the extra record.

That is interesting. I have a few smart pointer where I can use that as well.

Anyway, my plan is to reuse most of Ada.Containers.Hashed_Maps just making a small change get element. Currently I do it with inheritance and that works now. However I wonder if a delegate would be better and I only need two functions.

Background: The aim is a sparse array where reading non existing element should return 0 instead of throwing an exception.