Re: Ada-Singleton-Why does it work like this?

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

On Thu, 26 Mar 2009 01:55:46 -0700 (PDT), Martin wrote:

> On 25 Mar, 09:30, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
>> On Tue, 24 Mar 2009 17:10:11 -0700 (PDT), Martin wrote:
>>> On Mar 24, 8:47�pm, "Jeffrey R. Carter"
>>>> This is a very poor solution to the problem. A much simpler solution is
>>
>>>> package Singleton is
>>>> � � procedure Set (Value_1 : in Integer; Value_2 : in Integer);
>>
>>>> � � procedure Print;
>>>> end Singleton;
>>
>>> But you can not derive a class from this:
>>
>> Firstly you can. There are child packages in Ada, they are equivalent to
>> derivation.
>>
>> Secondly, you may not because it is a singleton. A derived variant would be
>> meaningless without making an instance of, which would be *another*
>> instance of now non-singleton.
> 
> Unless you use the "tagged type" version...and that would be ok, as a
> type is not an object. So you would have something like:
> 
> package Singletons is
>    type Singleton ...;
>    function Get_Instance return Singleton;
> end Singletons;
> 
> package Singletons.Thread_Safe is
>    type Thread_Safe_Singleton is new Singleton ...;
>    function Get_Instance return Thread_Safe_Singleton;
> end Singletons.Thread_Safe;
> 
> But only one object of either of these types could be instantiated.

This highlights the point. "Singletonness" is not a property of the type
used to implement it. So the pattern is all wrong. The type itself is not a
singleton, you only use it as if it were one. A proper design would be,
IMO:

package Singletons is
   procedure Do_Things;
private
   type Resusable_Object ...; -- Do not expose it
   procedure Implement_Do_Things (Instance : in out Resusable_Object);
end Singletons;

package body Singletons is
   Single : Resusable_Object;

   procedure Do_Things is
   begin
       Implement_Do_Things (Single);
   end Do_Things;
   ...
end Singletons;

package Singletons.Thread_Safe is
   procedure Do_Safe_Things;
private
   type Thread_Safe_Object is new Resusable_Object;
   overriding
      procedure Implement_Do_Things (Instance : in out Thread_Safe_Object);
end Singletons.Thread_Safe;

It is a question whether Resusable_Object should be put into the package
Singletons. Likely it could be used elsewhere not as a singleton. So in the
end, we still have the classic Ada design pattern of singletons:

with Anything_I_Need_To_Implement_This;

package Singletons is
   procedure Do_Things;
end Singletons;

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