Re: Merits of re-dispatching [LONG]

[brangdon@cix.co.uk (Dave Harris)]

dmitry@elros.cbb-automation.de (Dmitry A. Kazakov) wrote (abridged):
> That there are three types changes nothing. It works pretty well in
> Ada 95:

That still doesn't capture the full complexity, because although you have 
Foo you don't have a Call_Foo. The call to Foo from within Call_Foo must 
be dispatching, because it must dispatch to different places. Given that 
it can do this, it's simplest to say the call to Foo from within the 
destructor is dispatching too, in the same way. So there is no 
non-dispatching call in the C++.

I don't know Ada, but I think it would look like:

 type A is ...
 procedure Foo (Object : A) is
 begin
    Put_Line ("A.Foo");
 end Foo;
 procedure Call_Foo (Object : A) is
 begin
    Foo( Object );  -- Dispatching, A.Foo or B.Foo called.
 end Foo;
 procedure Finalize (Object : in out A) is
 begin
    Call_Foo (Object);
    Foo (Object);
 end Finalize;

 type B is new A ...
 procedure Foo (Object : B) is
 begin
    Put_Line ("B.Foo");
 end Foo;
 procedure Finalize (Object : in out B) is
 begin
    Call_Foo (Object); 
    Foo( Object );
    Finalize (A (Object));
 end Finalize;

This should produce B.Foo B.Foo A.Foo A.Foo. The call to Foo from 
B.Finalize can use exactly the same implementation as the call to Foo from 
A.Call_Foo. Both end up in B.Foo when the object is of type B. Both are 
dispatching calls.

  Dave Harris, Nottingham, UK | "Weave a circle round him thrice,
      brangdon@cix.co.uk      |   And close your eyes with holy dread,
                              |  For he on honey dew hath fed
 http://www.bhresearch.co.uk/ |   And drunk the milk of Paradise."