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

["patrick.gunia@googlemail.com" <patrick.gunia@googlemail.com>]

> As Pascal replied, the (<>) declares that Singleton_Type is
> unconstrained; because, in addition, it is private, it is therefore
> impossible to declare objects of this type outside the package
> Singleton.  Consider:
>
> with Singleton;
> procedure Wrong is
>    Second_Singleton : Singleton.Singleton_Type;
>    -- error, the type is unconstrained
>
> But your example is much too complicated.  Why is Singleton_Type
> tagged?  Why pass parameters to all subprograms when there is only one
> object anyway?  A proper singleton looks like this:
I used a tagged type because I wanted to use the Singleton
implementation as bsae class for other classes with more functionality
though sharing the singleton behaviour. Your right concerning the
parameter passing, if there´s only one instance, the parameter isn´t
necessary. Still I don´t get how the unconstrained type limits the
number of instances to 1. As Pascal said, this can be compared to the
String class which is implemenented as an unconstrained array of
Characters. Thus Strings either have to be initialized with a phrase
or you have to limit the range. Though I´m still able to create
hundreds of Strings in my program. Which mechanism is responsible for
prohibiting this to my singleton class? I mean, if I compare this type
to a String-variable, I could also say instance : Singleton_Type
(1..120); (something like this...) => But the compiler complains, but
why does he?


>
> package Singleton is
>    procedure Set (Value_1, Value_2 : in Integer);
>    procedure Print;
> private
>    Value_1, Value_2 : Integer;
> end Singleton;
>
> package body Singleton is
>    procedure Set (Value_1, Value_2 : in Integer) is
>    begin
>       Singleton.Value_1 := Value_1;
>       Singleton.Value_2 := Value_2;
>    end Set;
>
>    procedure Print is
>    begin
>       Put (Value_1);
>       Put (Value_2);
>    end Print;
> end Singleton;
>
> A variation of this design pattern is when you want to allocate the
> singleton dynamically on first use and never deallocate it.  In this
> situation, you do need an access type and value but you do not need to
> expose them to clients; in fact the whole allocation business should
> be confined to the body of the package:
>
> package body Singleton is
>
>    type Singleton_Type is record
>       Value_1, Value_2 : Integer;
>    end record;
>    type Singleton_Access is access Singleton_Type;
>    The_Singleton : Singleton_Access;
>
>    procedure Allocate_If_Null is
>    begin
>       if The_Singleton = null then
>          The_Singleton := new Singleton_Type;
>       end if;
>    end Allocate_If_Null;
>
>    procedure Set (Value_1, Value_2 : in Integer) is
>    begin
>       Allocate_If_Null;
>       The_Singleton.Value_1 := Value_1;
>       The_Singleton.Value_2 := Value_2;
>    end Set;
>
>    procedure Print is
>       -- raises Constraint_Error if The_Singleton = null, i.e. if Set
> never called
>    begin
>       Put (The_Singleton.Value_1);
>       Put (The_Singleton.Value_2);
>    end Print;
>
> end Singleton;
>
> HTH
>
> --
> Ludovic Brenta.