semi-visibility

semi-visibility

[tmoran]

I want to do the following, but it's illegal.  What's a good way to
accomplish the purpose, preferably without increasing the depth of
the package heirarchy, or enlarging package A.

private package A.B is
  type Visible_To_Relatives is ...
end A.B;

with A.B;
package A.C is
  type T is private;
  procedure P(x : in T);
private
  type T is record
    v : A.B.Visible_To_Relatives;
  end record;
end A.C;

with A.B;
package A.D is ...
  -- private part here similarly needs visibility of A.B

Re: semi-visibility

[Jeffrey Carter]

tmoran@acm.org wrote:
> I want to do the following, but it's illegal.  What's a good way to
> accomplish the purpose, preferably without increasing the depth of
> the package heirarchy, or enlarging package A.
> 
> private package A.B is
>   type Visible_To_Relatives is ...
> end A.B;
> 
> with A.B;
> package A.C is
>   type T is private;
>   procedure P(x : in T);
> private
>   type T is record
>     v : A.B.Visible_To_Relatives;
>   end record;
> end A.C;

One solution is to wait for Ada 0X. It has a way to to do this; IIRC, 
it's "with private".

If you need it sooner, one solution is

private
    type T_Implementation;
    type T is access [all] T_Implementation;
end A.C;

This gets you into possible problems with initialization and 
finalization that you might be able to alleviate by using Ada.Finalization.

A simpler solution is to make A.B non-private and attempt to enforce a 
rule that it only be referenced in the private parts and bodies of 
children of A.

-- 
Jeff Carter
"C's solution to this [variable-sized arrays] has real problems,
and people who are complaining about safety definitely have a point."
Dennis Ritchie

Re: semi-visibility

[Steve]

Is there some reason you don't want to put type Visible_To_Relatives in the
private part of A?

Steve
(The Duck)

<tmoran@acm.org> wrote in message news:YR8Ga.121540$d51.192359@sccrnsc01...
> I want to do the following, but it's illegal.  What's a good way to
> accomplish the purpose, preferably without increasing the depth of
> the package heirarchy, or enlarging package A.
>
> private package A.B is
>   type Visible_To_Relatives is ...
> end A.B;
>
> with A.B;
> package A.C is
>   type T is private;
>   procedure P(x : in T);
> private
>   type T is record
>     v : A.B.Visible_To_Relatives;
>   end record;
> end A.C;
>
> with A.B;
> package A.D is ...
>   -- private part here similarly needs visibility of A.B

Re: semi-visibility

[tmoran]

>Is there some reason you don't want to put type Visible_To_Relatives in the
>private part of A?
  Just that A is already bigger than I'd like.
But I've decided that once again, if Lady Ada slaps my wrist, she's right
and I didn't really want to do that anyway.  In this case that means
creating package A.BCD and renaming to A.BCD.C and A.BCD.D, possibly followed
(for less verbosity) by "package A.C renames A.BCD.C;" etc.

Re: semi-visibility

[Randy Brukardt]

Jeffrey Carter wrote in message <3EE92ACC.8010302@spam.com>...

>One solution is to wait for Ada 0X. It has a way to to do this; IIRC,
>it's "with private".


Actually, it's "private with" (see AI-262). And that's by far the best
solution, but it hasn't appeared in compilers yet.

               Randy.