Re: OOP in Ada: Alternatives for "protected" scope

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

On Thu, 3 May 2012 23:27:55 +0200, Felix Krause wrote:

> I have some abstract class A, defined in package P_A. This class 
> provides some functionality as procedure Do_Something. Now there is 
> some calculation to be done while execution Do_Something which cannot 
> be defined in A. Therefore, it is left to the specific child classes of 
> abstract class A to implement that calculation. The code might look 
> like this:

In that case Do_Something cannot be a primitive operation or else the
operation called from it must re-dispatch.

> package P_A is
>    type A is abstract tagged private;
> 
>    procedure Do_Something (Object : in out A);
>
>    function Calculate (Object : in out A) return Integer is abstract;

This is illegal in Ada 95-2005.

> private
>    -- define A here...
> end P_A;
> 
> package body P_A is
>    procedure Do_Something (Object : in out A) is
>       Var : Integer;
>    begin
>       -- some useful code here嚙皺
> 
>       -- let the specific child class define this calculation
>       Var := Calculate (Object);

This is wrong, it should have been

   Var := Calculate (A'Class (Object));

or else Do_Something should be declared class-wide:

   procedure Do_Something (Object : in out A'Class);

>       -- some more useful code here...
>    end Do_Something;
> end P_A;
>
> The function Calculate should only be used internally. I do not see a 
> good way to enforce this with Ada: I do not want to move it to P_A's 
> private part, because child classes of A should not be required to be 
> located in sub-packages of P_A. (It's also forbidden for an abstract 
> function to reside in the private part.)

If Do_Something varies in children they should override it. The reusable
parts common for all children can be factored out as a private class-wide
operation.

All children having access to private operations must be declared in
children packages.

   package P is
      type A is abstract tagged private;   
      procedure Do_Something (Object : in out A) is abstract;
   private
      ...
      procedure Do_Prologue  (Object : in out A'Class);
      procedure Do_Epilogue  (Object : in out A'Class);
   end P;

   package P.Q is
      type B is new A with private;
      overriding procedure Do_Something (Object : in out B);
      ...
   end P.Q;

   package body P.Q is
      procedure Do_Something (Object : in out B) is
      begin
          Do_Prologue (Object);
          ... -- Do specific calculations
          Do_Epilogue (Object);
      end Do_Something;
   end P.Q;

> In languages like Java and C#, there is a "protected" scope to cope 
> with this situation.

This is exactly what Ada's private is. The correspondence goes as follows:

"Public" <-> Ada' public operation
"Protected" <-> Ada's private operation
"Private" <-> An operation defined in the package body

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