Re: Operation can be dispatching in only one type

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

On Fri, 13 Nov 2009 12:12:18 -0800 (PST), xorque wrote:

> I'm trying to write an archive/directory abstraction in a similar vein
> to PhysicsFS
> but am at a bit of a loss as to how to design the archiver interface:
> 
> with Path;
> 
> package Archiver is
> 
>   type Archiver_t              is abstract tagged limited private;
>   type Archiver_Class_Access_t is access Archiver_t'Class;
> 
>   procedure Init
>     (Archiver : out Archiver_t) is abstract;
> 
>   function Can_Mount
>     (Archiver : in Archiver_t;
>      Path     : in Path.Real_t) return Boolean is abstract;
> 
>   type File_t              is abstract tagged limited private;
>   type File_Class_Access_t is access File_t'Class;
> 
>   procedure Open
>     (Archiver : in     Archiver_t;
>      Path     : in     Path.Virtual_t;
>      File     :    out File_t) is abstract;
> 
>   procedure Close
>     (File : in out File_t) is abstract;
> 
> private
> 
>   type Archiver_t is abstract tagged limited null record;
> 
>   type File_t is abstract tagged limited null record;
> 
> end Archiver;
> 
> The idea of the above is that the main part of the library only deals with
> archivers and "files" (which might only really be pointers to entries in Zip
> files, for example) by 'Class.
> 
> The problem with the above is that:
> 
> archiver.ads:18:13: operation can be dispatching in only one type
> 
> Hopefully someone here knows a better way to handle this.

Ada does not support multiple dispatch of this form. For simplicity
consider it does not support MD at all.

According to your code Open is doubly dispatching in Archiver_t and File_t
arguments. That does not work (unfortunately). You have to choose one and
make another class-wide. E.g.

procedure Open
    (Archiver : Archiver_t'Class; -- Class-wide
     Path     : Virtual_t;
     File     : in out File_t) is abstract;

This would be a primitive operation of File_t only.

P.S. If you indeed have to do MD, you should emulate it manually, by
dispatching within Open to some primitive operation of Archiver_t.

P.P.S. Do not use access types unless you need them.

P.P.P.S. Replace tagged limited with Ada.Finalization.Limited_Controlled,
sooner or later you almost certainly will need finalization and
initialization.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de