Re: I'm facing an issue with: call to abstract procedure must be dispatching

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

On Tue, 8 Dec 2015 10:00:24 -0800 (PST), Serge Robyns wrote:

> On Tuesday, 8 December 2015 18:42:26 UTC+1, Dmitry A. Kazakov  wrote:
>> On Tue, 8 Dec 2015 09:24:58 -0800 (PST), Serge Robyns wrote:
>> In which relation is Do_Something to T_Abstract_Store?
>> 
>> 1. a primitive operation =
>>       has a separate implementation for each concrete type (from the class)
>> 2. class-wide operation =
>>       has same implementation for all types (from the class)
>> 
>> (anything else is a design fault)
>> 
>>> Inside that procedure I'm using the A_Store. This regardless how A_Store
>>> got implemented.
>> 
>> That sounds like #2. Then it must be declared as:
> 
> This is indeed Correct.  Thanks for the tip.  Now it works, well at least it compiles .....
> 
> procedure test is
> 
>    type T_Store is new T_Asbtract_Store with null record;
> 
>    overriding procedure Insert (Store  : in out T_Store;
>                                 Client : in     T_Client'Class) is
>    begin
>       null;
>    end Insert;
>    
>    procedure Do_Something (A_Store : in out T_Asbtract_Store'Class)
>    is
>       Client    : T_Client;
>    begin
>       A_Store.Insert (Client);
>    end Do_Something;        
>    
>    A_Store   : access T_Asbtract_Store;

Observe that exactly same logic applies here. You never ever use a
type-specific access type when you deal with whole class. Thus, without any
further considerations it must be this:

   A_Store : access T_Asbtract_Store'Class;

<rant on> In each instance you should clearly understand whether the code
deals with one specific type or with all class. Once you know that, you
express this knowledge in terms of types. One of the major Ada advantages
with respect to OO is that it is properly typed. The type of a specific
instance and the type of all instances from the class are two *different*
types. The language rejected your program not because of being cruel, but
because you used one type as if it were another. <rant off>

>    The_Store : aliased T_Store;
> 
> begin
>    A_Store := T_Asbtract_Store (The_Store)'Access;

Now, of course no explicit type conversion required:

  A_Store := The_Store'Access;

(Type conversion must raise alarm bells)

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