Re: C++ to Ada95, help please

[stt@henning.camb.inmet.com (Tucker Taft)]

Simon Johnston (skj@rb.icl.co.uk) wrote:
: Hi, I am moving over to Ada95 from C++, I did do some Ada a while ago, and I
: am fairly confident, but I need some help to move some C++ knowledge onto
: Ada95.

: First I would like to declare an Opaque type, or in C++ a 'smiley'.  There
: are two uses for such a feature. 
: ...I include two 
: examples below to illustrate.

: // Start ->
: class ACollectionClass {
: public:
:   ...
: private:
:   class Implementation;
:   Implementation* hidden;
: };

Ada has a very direct equivalent to this:

    package A is
        type Collection is tagged private;
      ...
    private
	type Implementation;    -- This is called an "incomplete type"
			        -- it can only be used as the designated
				-- type for an access type before
				-- it is fully defined.
				-- The full definition may be deferred to the
				-- package body if the incomplete type
				-- definition is in the private part of
				-- the package spec.
        type Impl_Ptr is access Implementation;

        type Collection is tagged record
           B : Impl_Ptr;
        end record;
    end A;

  -- in the body for package A we would give the full definition
  -- of Implementation.

: class Screen {
: public:
:   ...
:   class SavedScreen;
:   const SavedScreen* save(void);
:   void  restore(SavedScreen* image);
: };
: // <- end.

This one is similar to the above, except that you export the access
type as a private type:

    package Screens is
        type SavedScreen is private;
	type Screen is tagged private;
        function Save(S : Screen) return Saved_Screen;
	procedure Restore(S : in out Screen; From : Saved_Screen);
    private
        type SavedScreen_Impl;
        type SavedScreen is access SavedScreen_Impl;

        type Screen is tagged record
           ...
        end record;
    end Screens;

  -- In the body for Screens, we would give the full definition
  -- for SavedScreen_Impl.

: Now I know from experience I can do this sort of thing in C++, Modula-2 and
: Modula-3 but I cannot see how to do it in Ada, even using private types.

As illustrated above, the thing you need to use are access types,
and a designated type which is an incomplete type whose full
type definition is deferred to the package body
(so called "deferred incomplete types")  This feature is
available in both Ada 83 and Ada 95.  

In Ada 95, you have the additional possibility of using abstract 
types and access-to-class-wide, which would allow the completion
of the "impl" types potentially in other packages, but
at least in the above cases, that seems like overkill.

If you are familiar with Modula-2, then an 
"access-to-deferred-incomplete-type" is almost identical
in functionality to Modula-2's "opaque" types.

: |Simon K. Johnston - Development Engineer (C/C++)      |ICL Retail Systems |
: |------------------------------------------------------|3/4 Willoughby Road|
: |Unix Mail : S.K.Johnston@bra0801.wins.icl.co.uk       |Bracknell, Berks   |
: |Telephone : +44 (0)344 476320   Fax: +44 (0)344 476302|United Kingdom     |
: |Internal  : 7261 6320    OP Mail: S.K.Johnston@BRA0801|RG12 8TJ           |

-Tucker Taft  stt@inmet.com
Intermetrics, Inc.