Re: How Can I Create A Class Dynamically

["Anthony E. Glover" <aglover@elmco.com>]

Thanks for the suggestion. I will give it a try.

Tony

"Samuel Tardieu" <sam@rfc1149.net> wrote in message
news:mailman.1001350161.22792.comp.lang.ada@ada.eu.org...
> On 24/09, Anthony E. Glover wrote:
>
> | I have a class hierarchy defined and I would like to be able to read a
> | string and then dynamically creating a pointer to an object of the type
> | specified by the string. Similar I think to class loading and class
> | factories in Java. Can this be done in Ada95. If so, how. I have looked
at
> | the Ada.Tags packages and this looks like it might be helpfull, but I'm
not
> | quite sure how to make use of it. I would basically like to be able to
avoid
> | having to specify a case statement or if block when initially creating
my
> | objects.
>
> Let's assume that the root of your hierarchy is called Root.
>
> One modular and portable way which would work with any language supporting
> elaboration would be to:
>
>  - have a package (probably using a protected object behind the scene)
which
>    exports a Register subprogram such as:
>
>           type Root_Access is access all Root'Class;
>           type Factory is access function return Root_Access;
>           procedure Register (Name : String; F : Factory);
>
>    Register would use a hash table to associate names to factories.
>
>  - in this package, also have a Create subprogram looking like:
>
>            function Create (Name : String) return Root_Access;
>
>    whose body would look like:
>
>           return Lookup (Name) .all;
>
>    (with of course added checks) where Lookup looks up in the hash table
>
>   - have each type register itself during the elaboration by declaring
>     a factory function and registering it using Register
>
> This way, you get a factory which knows only the types present in your
> final application.
>
> Note that you are likely to run into elaboration issues with the root type
> if your "factory-like package" is not the same as the one where the root
> type is declared.
>
> If your root type is abstract (or more generally if it cannot be used with
> a factory), then you can more easily solve elaboration problems. Also, it
> may be worth making a generic package to implement this solution.
>
> HopI hope you got the idea.e this helps.
>
>   Sam
>