Re: problem with abstract types

[Dmitry A.Kazakov <mailbox@dmitry-kazakov.de>]

Ulrich Eckhardt wrote:

> Thats exact my problem. I have no idea how to do it a better way.
> I use the package registry as some sort of interface, which sould
> make sure that for every instance a set of functions are declared.
> 
> But i can not or don't know how to declare an abstract type
> and assign later on a real type which is derived from this type.
> For example on java i can create an abstract type and also declare
> a variable of an abstract type. Later on the programm i can then
> instantiate a real type an assign it to this variable. Thats what i
> now want to do in java.

You cannot have a variable of an abstract type. Abstract types have no 
instances. Probably you want a variable which type is derived from some 
abstract type. Maybe you do not know the exact type of the variable. If so 
you could use class-wide objects. Make your registry object a non-limited 
type to have an ability to declare an abstract "constructor":

package Registry is
   type Registry_Object is abstract tagged private;
   function Create (...) return Registry_Object is abstract;
   function Get (...) return ... is abstract;
   procedure Put (...) is abstract;
private
   ...
end Registry;

package Registry.UNIX is
   type UNIX_Registry_Object (<>)  is new Registry_Object with private;
   function Create (...) return UNIX_Registry_Object;
   ...

UNIX_Registry_Object isn't abstract, so you have to implement all abstract 
primitive operations: Create, Get, Put. An instance of 
Registry_Object'Class can be then created as follows:

My_Registry : Registry_Object'Class := Registry.UNIX.Create (...);

Registry_Object is abstract. But Registry_Object'Class is not.

It might look useless in this example because the specific type of 
My_Registry is statically known, but it will have much sense if you would 
later create some sort of a registry factory package:

with Registry.UNIX;
with Registry.POSIX;
...

package Registry.Factory is
   type Registry_Type is (UNIX, POSIX, WINDOWS, ...);
   function Create (Which : Registry_Type, ...)
      return Registry_Object'Class;
...

Then you could well hide all nasty details:

with Registry;               use Registry;
with Registry.Factory;  use Registry.Factory;
...
My_Registry : Registry_Object'Class := Create (UNIX, ...);

-- 
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de