diotalevi has asked for the wisdom of the Perl Monks concerning the following question:

I needed Class::Singleton to expire its objects on some sort of schedule instead of the default immortality. In my case I want to create a sort of session object for a database wrapper, be able to find this data globally (hence the Singleton pattern) but still have it expire when then the session object goes out of scope of the containing routine. Hence Class::WeakSingleton. I'm going to upload it to CPAN but I want to get some feedback from anyone who feels like it on either implementation, style or whatever works.

{
    my $c = wrapper->instance;
    my $d = wrapper->instance;
    die "Mismatch" if $c != $d;
}   # wrapper->instance expires
{
    my $e = wrapper->instance;
    {
        my $f = wrapper->instance;
        die "Mismatch" if $e != $f;
    }
}   # wrapper->instance expires

package wrapper;
BEGIN { our @ISA = ('Class::WeakSingleton') }
sub ::DEBUG { 1 }
my $count = 0;
sub _new_instance {
    print "_new_instance()\n" if ::DEBUG;
    bless { (++$count) x 2 }, shift;
}

package Class::WeakSingleton;
use Scalar::Util ();

sub instance {
    my $class = shift;

    # get a reference to the _instance variable in the $class package
    no strict 'refs';
    my $instance = "${class}::_instance";

    return $$instance if defined $$instance;

    my $new_instance = $class->_new_instance(@_);
    $$instance = $new_instance;

    Scalar::Util::weaken( $$instance );

    return $new_instance;
}

[download]

Replies are listed 'Best First'.
Re: Please review Class::WeakSingleton
by rob_au (Abbot) on Jun 20, 2003 at 05:12 UTC
    Interesting - I don't know if I would still call this object a 'singleton' given this scope-based destruction, but I can understand the motivation and envision the requirements which has necessitated the development of this code.

    One question however, why not inherit from Class::Singleton directly and simply weaken the reference returned - For example (untested code follows):

    package Class::WeakSingleton;

use Class::Singleton;
use Scalar::Util ();

use vars qw/ @ISA /;
@ISA = qw/ Class::Singleton /;

sub instance
{
    my $class = shift;
    my $instance = $class->SUPER::instance( @_ );
    weaken( \$instance );
    return $instance;
}

1;

__END__

    [download]

    Update - Oops, my bad. Move along, nothing to see here ... :-)

     

    perl -le 'print+unpack"N",pack"B32","00000000000000000000001001101100"'

[reply]
[d/l]

      instance() is not documented as being available for inheritance and I didn't immediately see a way of doing that with subclassing. Not that I can't be daft at times. I think though... that your fix doesn't do the job right. The stored reference needs to be weakened, not the returned reference.

[reply]
        Ahhh, excellent point ... One test which I think you should be performing however (and that with which I proved that my own code proposal did not work as intended) is the following which tests the out-of-scope destruction of your weakened reference - This is important because Class::Singleton would pass the test examples in your code, whereas only Class::WeakSingleton would pass this test.

        {
    my $g = wrapper->instance;
    $g->{'key'} = 'value';
}
$h = wrapper->instance;
die "Bad mojo!" if exists $h->{'key'};

        [download]

         

        perl -le 'print+unpack"N",pack"B32","00000000000000000000001001101101"'

[reply]
[d/l]

Back to Seekers of Perl Wisdom