Re: Visibility issue

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On 14/09/2020 13:33, Daniel wrote:
> Thank you for your answer Dmitry. Let me focus and change my example to easier go to the problem. I will write some question to your answer at the end of the example.
> 
> I didn't write it in the example for simplicity, but the user has to set a callback function.
> This callback function is triggered in the internal implementation hierarchy packages. Let me show you the code within questions inside comments:
> 
> --- API SIDE: -----
> package API.Callbacks
>     type Handle is tagged private
>     type pointer_to_Procedure is access procedure (Self : API.CAllbacks.Handle );
>     procedure Set_Callback (Self: in out API_HandleCallBack; cp: CallbackProcedure  );
> private
>     type Handle is tagged record
>        Hidden : Natural;
>     end record;
>    procedure Hidden_constructor (S: in out Handle'Class ; Hidden_content :Natural);

You need a constructing function for your Handle

    package API.Callbacks
       type Handle is tagged private;
       function Create (Parameter : Natural) return Handle;

or else a factory object:

    type Factory is new
       abstract Ada.Finalization.Limited_Controlled with null record;
    function Create (Creator : in out Factory; ...)
       return Handle'Class is abstract;

> task body Caller is
> 
>   MyHandle : API.Handle;
>   cp: CallbackProcedure := Get_from_pool_of_callbacks;
> begin
>    Hidden_Constructor (MyHandle, 6);
>     --Cannot access to private part for API.Handle from here :(
>    -- compiler says that Hidden_Constructor is not a visible entity of" Callbacks"
>    -- I just wanted to build it to later call to the procedure:
>     cp (MyHandle);
> end Caller;

    task body Caller is
       My_Handle : Handle := Create (6);
    ...

As for callbacks, in Ada you could have a tagged object like 
Event_Handler. The callback will be a primitive operation of Event_Handler:

    type Event_Handler is
       abstract Ada.Finalization.Limited_Controlled with null record;
    procedure On_Event
              (  Handler : in out Event_Handler;
                 Object  : in out Handle
              )  is abstract;
    procedure Register
              (  Object  : in out Handle;
                 Handler : in out Event_Handler'Class
              );

The advantage: you derive from Event_Handler and can add whatever data 
you want.

Another pattern is a generic package or a generic subroutine. It is 
useful when you want to pass a closure, e.g. local variables to the 
callback without much fuss. E.g. a one-shot callbacks, visitors could be 
done this way.

    generic
       with function Visitor (Object : in out Handle'Class)
         return Boolean;
    procedure For_Each (Object : in out Handle'Class);

Both are capable to nicely breach privacy if you put them into child 
packages. Both do not suffer the accessibility level issues named access 
to subprogram types have.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de