Re: Runtime type selection

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

Randy Brukardt wrote:
> "Niklas Holsti" <niklas.holsti@tidorum.invalid> wrote in message 
> news:4ad23819$0$6256$4f793bc4@news.tdc.fi...
> ...
>> Did you read about the package Ada.Tags (RM 3.9)? There is a generic 
>> function Ada.Tags.Generic_Dispatching_Constructor that takes a tag as 
>> parameter and creates an object with that tag, but I don't hink there is 
>> any way to find the tags for all types in a given derivation class. So 
>> even with  Ada.Tags.Generic_Dispatching_Constructor your program still has 
>> to register the types, or their tags, or a prototype object of each type, 
>> to create the program-accessible set of types/tags that can be in the 
>> graph.
>>
>> Perhaps some expert can explain why this reflection capability (find tags 
>> for all derived types in a class) was not included in Ada.Tags? Perhaps 
>> because Ada run-time systems do not need such a function for their own 
>> purposes?
> 
> I think that would be impossible in general, for the same reason that the 
> rules about what tags are returned from calls to Internal_Tag are mostly 
> written with "may". The problem is that tagged types can be created and 
> cease to exist asychronously with respect to a call to a function in 
> Ada.Tags. (For instance, if another task creates a tagged type by calling a 
> subprogram with such a type declaration.) The model of Ada.Tags is that is 
> can be implemented either with a mostly static data structure (created at 
> link-time) or with a fully dynamic structure. In the latter case, complex 
> locking would be required to ensure any particular (useful) answer for one 
> of these functions. In the former case, something similar to the dynamic 
> structure (and locking) would be required to avoid returning non-existent 
> tags. It was felt that such requirements would add a lot of complication and 
> runtime cost to the implementation of this package without a corresponding 
> benefit.

Thanks for this clear explanation, Randy. Interesting to hear that this 
question was actually discussed by the language definition team.

> The only language requirement is that each tagged type is 
> connected to its immediate parent (in order to check type conversions), 
> anything else further would be needed only to implement your proposed 
> function.

Well, I did not really mean to "propose" such a function, I only tried 
to explain to the OP (who could have made use of this functionality) 
that it is not provided now, but I could not myself explain why not, as 
you could.

As I understand it, Ada is not designed to support much reflection, so 
the absence of this function does not surprise or disappoint me. I don't 
know about the OP, of course...

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .