Re: Runtime type selection

[mockturtle <framefritti@gmail.com>]

On Oct 11, 6:41 pm, xorque <xorquew...@googlemail.com> wrote:
> Hello.
>
> I'd like to develop a program that processes a graph. The contents of
> the graph are a random selection of objects of different types (all
> elements may be of the same type or may all be different - assuming
> there are enough types defined). By 'type' in this case, I am
> referring
> to Ada types.
>
> The basic problem is that I want to create an object of a type picked
> at
> random, at runtime. I'm not entirely sure what my options are here.
>
> I could create a base tagged type and derive a set of types from that
> base, selecting at random. I could use variant records. It seems that
> in
> either case, I'd need to create an enumeration type with a 1:1 mapping
> between enumeration values and derived types.
>
> Both of these solutions seem a little unwieldly. They also seem like
> they'd end up making the program difficult to extend (I'd ideally just
> like to derive a new type and have it automatically available to be
> selected at random for the graph).
>
> Any ideas would be appreciated. I appreciate the problem is a little
> abstract...

I am making this  suggestion as I write, so maybe it could prove
unfeasible, but maybe it will inspire you.

I would create a base tagged type, so that all your types are
descendent of a common ancestor.  Then I would define a "constructor
callback", that is a type that represents an access to a function that
return a class-wide access type to a newly created object. Finally, I
would create a container (a vector?) of constructor callbacks.   More
or less, something like this

   type Root is tagged null record;

   type Root_Class_Access is access Root'Class;

   type Callback is access function return Root_Class_Access;

   package Callback_Vectors is
       new Containers.Vectors(Natural, Callback);

   Callback_Table : Callback_Vectors.Vector;

[Please note: I did not check the code above with an actual Ada
compiler, so maybe it is full of errors (beside the missing "with"),
but I hope it clarifies what I mean]

 When I want to add a new type to my system, I simply "register" the
constructor of the new type by inserting it into Callback_Table.  When
I want to generate an object at random I simply choose one callback
from the container and call it.

As I said, I made this in "real time" while writing, so I hope this
makes some sense... ;-)

Cheers