Re: Runtime type selection

["Randy Brukardt" <randy@rrsoftware.com>]

"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.

Finally, to actually implement some way to determine all of the tags of a 
particular class would require either a brute force search of all tags (very 
slow) or some complex additional data structures. (Remember that *every* 
tagged type and subtype has a corresponding 'Class, so this structure could 
get very large if you are using software that defines a lot of tagged types 
as Claw does.) 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. Even a list of all tags is not required to implement the language 
(although you may have a way to get it depending on your Ada.Tags 
implementation).

                                                 Randy.