Re: Mut. Recurs. in Ada9X w/o Breaking Encaps.? (LONG)

[Magnus.Kempe@di.epfl.ch (Magnus Kempe)]

Norm's solution could be further improved as follows:

: One variation on this is to declare recursive types meant to serve as the
: parents of types Employee and Office, but to provide no operations for
: these recursive types.  Then, in child packages, declare Employee and
: Office themselves as derived types and declare primitive operations in
: those child packages: 

Since this couple of recursive types is strictly internal to the
abstraction "employee and his office", I recommend that they be
declared as abstract and hidden in the private part of the parent
package (Yes, this compiles with GNAT):

    package Company is
    private
      type Employee_Parent;
      type Employee_Pointer is access all Employee_Parent'Class;

      type Office_Parent;
      type Office_Pointer is access all Office_Parent'Class;


      type Employee_Parent is abstract tagged
        record
          Its_Occupied_Office : Office_Pointer;
        end record;

      type Office_Parent is abstract tagged
        record
          Its_Occupying_Employee : Employee_Pointer;
        end record;
    end Company;

The rest of Norm's solution doesn't change; the couple of abstractions
Employee and Office is declared in two child units of Company.  To the
client programmer, the encapsulation is strong but the relationship
between the two abstractions is quite apparent because they are exported
by the Company.* subsystem (a hierarchy of packages).

-- 
Magnus Kempe		"I know not what course others may take, but as for me,
Magnus.Kempe@di.epfl.ch  Give me Liberty... or give me Death!" -- Patrick Henry