Actually, I do not believe that the full Rational subsystem export control
mechanism can be duplicated with Ada 95's child packages, except in certain
Suppose we have a subsystem composed of several "peer" packages which
themselves mutually depend on a set of support packages. The top level
packages might all be exported from a subsystem, while all subordinates are
not. Ada 95's parent-child packaging is really a strict hierarchy, and does
not permit multiple parents to share the functions from child packages.
Only if there is ONE top level package would Tucker's solution apply. In
most cases I have seen, this is rarely the case.
Now one could consider creating a super-package containing all the parent
packages, but that would change all points of usage -- something I would not
It is my personal feeling that Rational's subsystems addresses a different
control issue than Ada 95's parent/child package system. I would suggest
that Ada 95 child/parent packaging be used for encapsulation and hiding of
implementation details for a parent package that needs subpackages specific
to its implementation.
Conversely, Rational's export control mechanism is appropriate for
controlling exports within a subsystem of communicating "peer" packages in
which only some of the communications should come from outside the
Thus I would think there would be some cases in your application where Ada
95's parent/child packaging would be appropriate to maintaining the
integrity of your system, and some cases where Rational's subsystem export
controls would benefit your system integrity.
Forcing either mechanism to do the work of the other may work against any
improvement of system integrity -- essentially make work for no or negative
On Tuesday, October 20, 1998 12:13 PM, Tucker Taft [SMTP:[log in to unmask]]
> > Hence, as I understand it, it should be possible to transform the Ada83
> > source of a system built as a set of components to a corresponding set
> > of
> > top level "component packages" with public and private child packages in
> > Ada95.
> > Is this possible? Has it been done? Is it a stupid idea alltogether? Any
> > other ideas?
> To answer this question more directly: yes it can be done
> pretty straightforwardly. The fundamental rules are that
> a private child cannot be "with"ed outside the "subsystem"
> rooted at its parent, and cannot be "with"ed by the spec of
> any unit visible to "outsiders."
> A "subsystem" is a tree of library units headed by some particular
> library unit.
> Another way of looking at it is that a subsystem can be divided
> into two parts: the part visible outside the subsystem (the "interface"
> to the subsystem), and the part visible only inside the subsystem
> (the "implementation" of the subsystem). The interface consists of
> the specs of the root of the subsystem and its public children,
> grandchildren, etc. The implementation consists of the
> specs of the private children/grandchildren, etc, plus all the bodies.
> Something outside the subsystem, or something in the interface of the
> subsystem, may not "with" something in the implementation.
> > Thanks for any replies.
> > Cheers, Dan
> > Daniel Wengelin, CelsiusTech Systems
> > [log in to unmask]
> -Tucker Taft [log in to unmask]