comp.lang.ada
 help / color / mirror / Atom feed
From: Samuel Tardieu <sam@rfc1149.net>
To: comp.lang.ada@ada.eu.org
Subject: Re: How Can I Create A Class Dynamically
Date: Mon, 24 Sep 2001 18:48:54 +0200
Date: 2001-09-24T18:48:54+02:00	[thread overview]
Message-ID: <mailman.1001350161.22792.comp.lang.ada@ada.eu.org> (raw)
In-Reply-To: <1bJr7.11813$po4.573186@e420r-atl1.usenetserver.com>

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




  reply	other threads:[~2001-09-24 16:48 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2001-09-24 16:32 How Can I Create A Class Dynamically Anthony E. Glover
2001-09-24 16:48 ` Samuel Tardieu [this message]
2001-09-25 12:40   ` Anthony E. Glover
2001-10-01 12:35 ` Lutz Donnerhacke
2001-10-02 23:13   ` R. Tim Coslet
2001-10-04  8:55     ` Lutz Donnerhacke
2001-10-04 16:39       ` Pascal Obry
2001-10-04 17:06       ` R. Tim Coslet
replies disabled

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox