From mboxrd@z Thu Jan 1 00:00:00 1970 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00 autolearn=ham autolearn_force=no version=3.4.4 X-Google-Language: ENGLISH,ASCII-7-bit X-Google-Thread: 103376,7a180be12347b9d3 X-Google-Attributes: gid103376,public X-Google-Thread: 1108a1,7a180be12347b9d3 X-Google-Attributes: gid1108a1,public X-Google-ArrivalTime: 2002-02-18 00:57:12 PST Path: archiver1.google.com!news1.google.com!newsfeed.stanford.edu!news-spur1.maxwell.syr.edu!news.maxwell.syr.edu!newsfeed00.sul.t-online.de!t-online.de!newsfeed.r-kom.de!fu-berlin.de!uni-berlin.de!tar-alcarin.cbb-automation.DE!not-for-mail From: dmitry@elros.cbb-automation.de (Dmitry A. Kazakov) Newsgroups: comp.lang.ada,comp.object Subject: Re: Merits of re-dispatching [LONG] Date: Mon, 18 Feb 2002 08:57:11 GMT Message-ID: <3c70b935.501062@News.CIS.DFN.DE> References: <3c6bcb27.4632484@News.CIS.DFN.DE> NNTP-Posting-Host: tar-alcarin.cbb-automation.de (212.79.194.111) X-Trace: fu-berlin.de 1014022631 2374058 212.79.194.111 (16 [77047]) X-Newsreader: Forte Free Agent 1.21/32.243 Xref: archiver1.google.com comp.lang.ada:20104 comp.object:34592 Date: 2002-02-18T08:57:11+00:00 List-Id: On Sat, 16 Feb 2002 12:10 +0000 (GMT Standard Time), brangdon@cix.co.uk (Dave Harris) wrote: >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. One correction, it should be: Foo (A'Class (Object)); -- Re-dispatch to "native" Foo > 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. With my correction it will produce: B.Foo B.Foo B.Foo A.Foo. \ \ \ \ \ \ \ Foo from A.Finalize -> A.Foo \ \ Call_Foo form A.Finalize -> B.Foo (dispatch) \ Foo from B.Finalize -> B.Foo Call_Foo form B.Finalize -> B.Foo (dispatch) Alternatively, you could make Call_Foo class wide: procedure Call_Foo (Object : A'Class) is begin Foo (Object); -- Dispatching end Call_Foo; This is the official way to say that we want to dispatch on A from it and thus it is defined for all A derivates. [=>it cannot be overridden] Then a call to Call_Foo form B.Finalize could look as follows: Call_Foo (A'Class (Object)); -- Prepare Object to re-dispatching The result output will be same. [Ada is a consistent language (:-))] >The call to Foo from B.Finalize can use exactly the same implementation >as the call to Foo from A.Call_Foo. If both are dispatching, but they are not. Only the call from Call_Foo is dispatching. >Both end up in B.Foo when the object is of type B. Both are >dispatching calls. That's the point. Why on earth a call to Foo from B.Finalize should dispatch? The type is known, so there is only one version of Foo to be called. It can be resolved at compile time and even inlined if necessary. In Ada it does not dispatch. And that is good. But my point was that additionally to that there must be no way to enforce dispatching [like in Call_Foo], because it is unsafe and inefficient. Regards, Dmitry Kazakov