Help with notations for Tagged Types and Child Libraries

[koehnema@enuxsa.eas.asu.edu (Harry Koehnemann)]

The world's full of design notations that represent class constructs.
For example the following code:

	class Bank_Account {
	public:	
		Deposit (int amount) { ... }
	private:
		int account_number;
		int balance;
	};

is drawn in a notation that shows the class name, operations, and data
somthing like:
			----------------
			|Bank_Account  |
			|--------------|
			|Deposit       |
			|--------------|
			|Account_Number|
			|Balance       |
			----------------

Inheritance in such a notation is shown by drawing arrows from a child
class to it's parent class.  Symbols are added to represent aggregation,
composition (composed_of vs. kind_of), and decomposition (subsystems).

Ada95 OO extensions appear to map to this notation, but add a few
interesting twists.  Packages present the first problem for me.  How are
packages and child packages denoted/added to such a notation?  They're not
really subsystems - subsystem can be compsed of many packages, and are
likely decomposed into many child units.  Further, child packages support
many purposes - decomposition, extensions, multiple interfaces, etc.
Modeling packages as a container for OO is probably not appropriate as a
general case.  How is anyone modeling type extensions and inheritance in
conjunction with child packages?

A second problem occurs when a type extensions's interface is derived from
one type, but it's implementation (the declaration in the private part) is
derived from a different type.  How does one denote a type with two
derivations - one for the public interface and one for the implementation
interface?

Any references, comments, or suggestions would be appreciated.

--
Harry Koehnemann			Arizona State University
hek@asu.edu				Computer Science Department