Re: APQ

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

On Wed, 05 Jan 2005 08:32:53 +1100, Brian May wrote:

>>>>>> "Dmitry" == Dmitry A Kazakov <mailbox@dmitry-kazakov.de> writes:
> 
>     Dmitry> You probably mean this:
> 
>     Dmitry> function Copy (C : Root_Connection_Type'Class)
>     Dmitry> return Root_Connection_Ptr is
>     Dmitry> begin
>     Dmitry> return new Root_Connection_Type'Class'(C);
>     Dmitry> end Copy;
> 
>     Dmitry> This indeed cannot work for limited types. This was the
>     Dmitry> reason why Copy was declared abstract primitive instead:
> 
>     Dmitry> function Copy (C : Root_Connection_Type)
>     Dmitry> return Root_Connection_Ptr is abstract;
> 
>     Dmitry> It will dispatch to an implementation which knows how to
>     Dmitry> copy itself:
> 
> I am under the impression (perhaps wrong impression, I haven't tested
> it) that
> 
> A := Copy(C);
> 
> will not work if C is a limited type, as there is an implied copy
> operation from the RHS to the LHS.

The following is an fully operational implementation of what I meant based
on Simple Components (http://www.dmitry-kazakov.de/ada/components.htm):

  -- The test program first:

with Connections;  use Connections;
with Connections.My_Connections;

procedure Test_Connections is
   A : Connection; -- Illegal, will not compile
   B : Connection := Connections.My_Connections.Create (10);
   C : Connection := Copy (B); -- Make a copy
   D : Connection := B; -- Reference
begin
   null;
end Test_Connections;

Here B and D are handles to the same internal connection object. They share
it. C is a handle to a copy of the object pointed by B,D. The connection
objects are automatically destroyed when the last handle disappear. User
sees only the type Connection.

   -- Abstract connection interface. A connection is a handle to
   -- the connection object. Handles are not limited, objects are.

with Object;
with Object.Handle;

package Connections is
   type Connection (<>) is private;
   function Copy (C : Connection) return Connection;
   
private
   type Root_Connection_Object is
      abstract new Object.Entity with null record;
   type Root_Connection_Ptr is access Root_Connection_Object'Class;
   function Copy (C : Root_Connection_Object)
      return Root_Connection_Ptr is abstract;

   package Connection_Handles is
      new Object.Handle (Root_Connection_Object, Root_Connection_Ptr);
   type Connection is new Connection_Handles.Handle with null record;
   function Ref (C : Root_Connection_Ptr) return Connection;
end Connections;

package body Connections is
   function Copy (C : Connection) return Connection is
   begin
      return Ref (Copy (Ptr (C).all));
   end Copy;

   function Ref (C : Root_Connection_Ptr) return Connection is
   begin
      return (Connection_Handles.Ref (C) with null record);
   end Ref;
end Connections;

  -- An implementation: My_Connection

package Connections.My_Connections is
   function Create (Parameter : Integer) return Connection;

private
   type My_Connection_Object is new Root_Connection_Object with record
      I : Integer;
   end record;
   function Copy (C : My_Connection_Object) return Root_Connection_Ptr;

end Connections.My_Connections;

package body Connections.My_Connections is
   function Create (Parameter : Integer) return Connection is
      This   : Root_Connection_Ptr := new My_Connection_Object;
      Object : My_Connection_Object
                  renames My_Connection_Object (This.all);
   begin
      Object.I := Parameter;
      return Ref (This);
   end Create;

   function Copy (C : My_Connection_Object) return Root_Connection_Ptr is
      This   : Root_Connection_Ptr := new My_Connection_Object;
      Object : My_Connection_Object
                  renames My_Connection_Object (This.all);
   begin
      Object.I := C.I;
      return This;
   end Copy;

end Connections.My_Connections;

> Also the thread "Return_By_Reference or Return_By_Copy (GNAT bug?)" might
> be relevant here.

Only in Ada 2005 there will be a way to have limited object constructors.
Which will be BTW still too little for a proper construction model. There
still will be no constructors with parameters. No copy constructors. No
class-wide constructors.

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