Re: Need advice re package organization.

[Stephen Leake <Stephe.Leake@nasa.gov>]

"Randy Brukardt" <randy@rrsoftware.com> writes:

> "Warren W. Gay VE3WWG" <ve3wwg@cogeco.ca> wrote in message
> news:7GfWa.5186$mv6.907516@news20.bellglobal.com...
> <snip>
> >
> > We're talking about protected access of classes (C++).
> 
> As I said above, I don't know C++ well enough to know exactly what it is
> that you are proposing. And in any case, Ada is not C++. Please describe
> what you want in Ada terms, with Ada syntax.

Perhaps I can help, since I beleive I do know C++ and Ada well enough
:).

The C++ notions of public, protected, and private member functions do
not map one-to-one into Ada, but they map fairly well according to the
following scheme (data members below):
       
C++         Ada
public      public part of package spec
protected   private part of package spec
private     package body

C++ can make the same distinctions among data members of a record
type. For example:

class Foo
{
public:
   int A;
protected:
   int B;
private:
   int C;
}

A is visible to all children and clients of Foo; B is visible to
children of Foo; C is only visible within Foo.

To achieve the same visibility in Ada, we need to break up the record
type:

package Foo_Package is

   type Protected_Foo is private;

   type Foo is record
      A : Integer;
      Protected_Stuff : Protected_Foo;
   end record;

private
   type Private_Foo;
   type Private_Foo_Access is access Private_Foo;

   type Protected_Foo is record
      B : integer;
      Private_Stuff : Private_Foo_Access;
   end record;
end Foo_Package;

package body Foo_Package is
   type Private_Foo is record
       C : Integer;
   end type;
   
end Foo_Package;

If you are comming from a C++ background, the Ada approach seems
contorted. From an Ada point of view, the C++ approach seems
simplistic :).


I believe I have seen proposals that allow a single Ada record to have
public and private parts, something like:

package Foo_Package is

   type Foo is record
      A : Integer;
   end record with private;

private

   type Foo is record with private
      B : integer;
   end record;

end Foo_Package;

But that only achieves the C++ protected visibility, not the private.

-- 
-- Stephe