Re: The "()" operator revisited.

["Frank J. Lhota" <NOSPAM.lhota.adarose@verizon.net>]

"Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
news:wcczncpgjzv.fsf@shell01.TheWorld.com...
> The C++ way has some advantages over the Ada way (where the user's
> control is split between Finalize and Adjust) because it's sometimes
> convenient to get your hands on both sides of the assignment at the same
> time.

You can get access to both sides of an assignment in Ada 95, using a variant
of the Rosen trick. The idea is to add a component to the controlled object
that holds an access value for the object itself, e.g.

   type My_Controlled_Access is access all My_Controlled_Type;

   type My_Controlled_Type is new Ada.Finalization.Controlled with
      record
         Self : My_Controlled_Access;    -- Always accesses the containing
object.
         ...
      end record;

   procedure Initialize(Object : in out My_Controlled_Type) is
   begin
      Object.Self := Object'Access;
      ...
   end Initialize;

Now when Adjust is called, the object will be a bit copy of the right hand
side of the assignment. In particular, this gives you a component with an
access value for the right hand side. In Adjust, we can simply save the
value of this component, and reset it to access the left hand of the
assignment (i.e. the current object). Now we have access to both sides of
the assignment, e.g.

   procedure Adjust(Object : in out My_Controlled_Type) is
      Right_Hand_Side : constant My_Controlled_Access := Object.Self;
   begin
      Object.Self := Object'Access;
      -- Now the left hand side of the assignment is in Object,
      -- and the Right Hand side is in the saved value of Object.Self.
      ...
   end Adjust;

Note that although the Rosen trick works, it is, after all, still a trick. I
agree that there are probably cases where it would be nice to be able to
define the ":=" operator in Ada. As someone who has coded in both Ada and
C++, I must however admit that in most cases I have found the Initialize /
Adjust / Finalize coding to be easier than doing the C++ equivalents.