Re: Need advice re package organization.

["Matthew Heaney" <matthewjheaney@earthlink.net>]

"Warren W. Gay VE3WWG" <ve3wwg@cogeco.ca> wrote in message
news:clWVa.4191$mv6.741217@news20.bellglobal.com...
>
> The problem occurs in the private child package (IMO) because
> you want to derive new objects from parent tagged records. The
> danger that develops is that the child package's body code may
> monkey with things in the parent object that you don't want it
> to (this is lack of information hiding).

That the private part of the parent package is visible to (the private part
of) a child is a feature of the language.

Yes, there is a "lack of information hiding," but the syntax of the language
is designed so that it's obvious who has access to the private information,
e.g. if I see P.C, I know that C has visibility to P.

This is a consequence of the fact that visibility in Ada is controlled by
the module relationship.  One issue in C++ is that if I have:

class B
{
public:
   virtual ~B();
protected:
   secret_t m_secret;
};

then yes, this says that data member m_secret is visible to classes that
derive from B, but there's nothing that identifies which classes those are.
If I see a class D, there's nothing to tell me that D derives from B (unless
you look at D's declaration, of course).

This is why I usually name derived classes by tacking the derived name onto
the base class name, e,g

class Presentation { /* ... */ };
class PresentationAVI : public Presentation { /* ... */ };
etc

class Stream { /* ... */ };
class StreamAVI : public Stream { /* ... */ };
class StreamWAV : public Stream { /* ... */ };
etc.

At least in Ada, if I have one type that derives from another, e.g.

package P is
   type T is tagged ...;
...
end P;

package P.C is
   type NT is new T with ...;
...
end P.C;

then at least when I see P.C.NT, I know immediately that C can see the
private part of P.

So I don't agree that one should that a parent package should try to "hide"
stuff from a child.  The set of modules that have visibility to the private
part of P (and hence, that need to be consulted if there is a change) is
bounded, and clearly demarcated.  In the typical case the members of a
package hierarchy (the "subsystem") would be kept together in a project,
probably in the same directory, and maintained by a single person.