Free class file has wrong version 50.0 software for linux

Class::StrongSingleton is a stronger and more secure Singleton base class.

SYNOPSIS

package My::Singleton::Class;

use base qw(Class::StrongSingleton);

sub new {
my ($class, %my_params) = @_;
# create our object instance
my $instance = { %my_params };
bless($instance, $class);
# and initialize it as a singleton
$instance->_init_StrongSingleton();
return $instance;
}

1;

# later in your code ...

# create the first instance of our class
my $instance = My::Singleton::Class->new(param => "value");

# try to create a new one again, and
# you end up with the same instance, not
# a new one
my $instance2 = My::Singleton::Class->new(param => "other value");

# calling instance returns the singleton
# instance expected
my $instance3 = My::Singleton::Class->instance();

# although rarely needed, if you have to
# you can destroy the singleton

# either through the instance
$instance->DESTROY();
# or through the class
My::Singleton::Class->DESTROY();

# of course, this is assuming you
# did not override DESTORY yourself

# Also calling instance before calling new
# will returns a new singleton instance
my $instance = My::Singleton::Class->instance();

This module is an alternative to Class::Singleton and Class::WeakSingleton, and provides a more secure Singleton class in that it takes steps to prevent the possibility of accidental creation of multiple instances and/or the overwriting of existsing Singleton instances. For a detailed comparison please see the "SEE ALSO" section.

Here is a description of how it all works. First, the user creates the first Singleton instance of the class in the normal way.

my $obj = My::Singleton::Class->new("variable", "parameter");

This instance is then stored inside a lexically scoped variable within the Class::StrongSingleton package. This prevents the variable from being accessed by anything but methods from the Class::StrongSingleton package. At this point as well, the new method to the class is overridden so that it will always return the Singleton instance. This prevents any accidental overwriting of the Singleton instance. This means that any of the follow lines of code all produce the same instance:

my $instance = $obj->instance();
my $instance = My::Singleton::Class->instance();
my $instance = $obj->new();
my $instance = My::Singleton::Class->new();

Personally, I see this an an improvement over the usual Gang of Four style Singletons which discourages the use of the new method entirely. Through this method, a user can be able to use the Singleton class in a normal way, not having to know its actually a Singleton. This can be handy if your design changes and you no longer need the class as a Singleton.

EXAMPLE

# This is a really long synopsis, but hopefully it will give you an idea...

package MyPackage;

use Class::Driver;
use base q(Class::Driver);

our %drivers;

return 1;

sub new {
my($class, %args) = @_;
die "mime_type is required" unless($args{mime_type});
die "no driver to handle type $args{mime_type}"
unless($drivers{$args{mime_type}});
return $class->driver_load($drivers{$args{mime_type}}, %args);
}

sub driver_new {
my($class, %args) = @_;
return bless %args, $class;
}

sub driver_required { 1; }
sub driver_requied_here { 0; }

package MyPackage::avi;

use MyPackage;
use base q(MyPackage);
use Video::Info;

$MyPackage::drivers{video/x-msvideo} = avi;

return 1;

sub driver { "avi"; }

sub driver_new {
my($class, %args) = @_;
die "file is a required parameter for $args{mime_type} files"
unless($args{file});
$args{info} = Video::Info->new(-file => $args{file})
or die "Failed to create a Video::Info object for $args{file}";
return $class->SUPER::driver_new(%args);
}

sub duration {
my $self = shift;
return $args{info}->duration;
}

package MyPackage::mp3;
use base q(MyPackage);
use MP3::Info;

$MyPackage::drivers{audio/mpeg} = mp3;

## (etc...)

package main;

my $foo = MyPackage->new(file => foobar.mp3, mime_type => audio/mpeg);
print "foobar.mp3 is ", $foo->duration, " seconds long.n";

Class::Inner is a perlish implementation of Java like inner classes.

SYNOPSIS

use Class::Inner;

my $object = Class::Inner->new(
parent => ParentClass,
methods => { method => sub { ... } }, },
constructor => new,
args => [@constructor_args],
);

Yet another implementation of an anonymous class with per object overrideable methods, but with the added attraction of sort of working dispatch to the parent classs method.

METHODS

new HASH

Takes a hash like argument list with the following keys.

parent

The name of the parent class. Note that you can only get single inheritance with this or SUPER wont work.

methods

A hash, keys are method names, values are CODEREFs.

constructor

The name of the constructor method. Defaults to new.

args

An anonymous array of arguments to pass to the constructor. Defaults to an empty list.

Returns an object in an anonymous class which inherits from the parent class. This anonymous class has a couple of extra methods:

SUPER

If you were to pass something like

$obj = Class::Inner->new(
parent => Parent,
methods => { method => sub { ...; $self->SUPER::method(@_) } },
);

then $self-gtSUPER::method almost certainly wouldnt do what you expect, so we provide the SUPER method which dispatches to the parent implementation of the current method. There seems to be no good way of getting the full SUPER:: functionality, but Im working on it.

DESTROY

Because Class::Inner works by creating a whole new class name for your object, it could potentially leak memory if you create a lot of them. So we add a DESTROY method that removes the class from the symbol table once its finished with.

If you need to override a parents DESTROY method, adding a call to Class::Inner::clean_symbol_table(ref $self) to it. Do it at the end of the method or your other method calls wont work.

clean_symbol_table

The helper subroutine that DESTROY uses to remove the class from the symbol table.

new_classname

Returns a name for the next anonymous class.

Class::InsideOut is a Perl module with a safe, simple inside-out object construction kit.
SYNOPSIS
package My::Class;
use Class::InsideOut qw( public private register id );
public name => my %name; # accessor: name()
private age => my %age; # no accessor
sub new { register( shift ) }
sub greeting {
my $self = shift;
return "Hello, my name is $name{ id $self }";
}
This is a simple, safe and streamlined toolkit for building inside-out objects. Unlike most other inside-out object building modules already on CPAN, this module aims for minimalism and robustness:
- Does not require derived classes to subclass it
- Uses no source filters, attributes or CHECK blocks
- Supports any underlying object type including black-box inheritance
- Does not leak memory on object destruction
- Overloading-safe
- Thread-safe for Perl 5.8 or better
- mod_perl compatible
- Makes no assumption about inheritance or initializer needs
It provides the minimal support necessary for creating safe inside-out objects and generating flexible accessors.

Class::Agreement is a Perl module that add contracts to your Perl classes easily.

SYNOPSIS

package SomeClass;

use Class::Agreement;

# use base Class::Accessor or Class::MethodMaker,
# or roll your own:
sub new { ... }

invariant {
my ($self) = @_;
$self->count > 0;
};

precondition add_a_positive => sub {
my ( $self, $value ) = @_;
return ( $value >= 0 );
};
sub add_a_positive {
my ( $self, $value ) = @_;
...
}

sub choose_word {
my ( $self, $value ) = @_;
...
}
postcondition choose_word => sub {
return ( result >= 0 );
};

dependent increase_foo => sub {
my ( $self, $amount ) = @_;
my $old_foo = $self->foo;
return sub {
my ( $self, $amount ) = @_;
return ( $old_foo < $self->get_foo );
}
};
sub increase_foo {
my ( $self, $amount ) = @_;
$self->set_foo( $self->get_foo + $amount );
}

Class::Agreement is an implementation of behavioral contracts for Perl5. This module allows you to easily add pre- and postconditions to new or existing Perl classes.
This module provides contracts such as dependent contracts, contracts for higher-order functions, and informative messages when things fail.

At the time of this writing, Class::Agreement is one of only two contract implementations that blames contract-breaking components correctly. (See: "Object-oriented Programming Languages Need Well-founded Contracts" at http://citeseer.ist.psu.edu/findler01objectoriented.html.)
Using Class::Agreement lets you specify proper input and output of your functions or methods, thus strengthening your code and allowing you to spot bugs earlier.

Class::Delegation is a Perl object-oriented delegation.

SYNOPSIS

package Car;

use Class::Delegation
send => steer,
to => ["left_front_wheel", "right_front_wheel"],

send => drive,
to => ["right_rear_wheel", "left_rear_wheel"],
as => ["rotate_clockwise", "rotate_anticlockwise"]

send => power,
to => flywheel,
as => brake,

send => brake,
to => qr/.*_wheel$/,

send => halt
to => -SELF,
as => brake,

send => qr/^MP_(.+)/,
to => mp3,
as => sub { $1 },

send => -OTHER,
to => mp3,

send => debug,
to => -ALL,
as => dump,

send => -ALL,
to => logger,
;

Class::CGI is a Perl module to fetch objects from your CGI object.

SYNOPSIS

use Class::CGI
handlers => {
customer_id => My::Customer::Handler
};

my $cgi = Class::CGI->new;
my $customer = $cgi->param(customer_id);
my $name = $customer->name;
my $email = $cgi->param(email); # behaves like normal

if ( my %errors = $cgi->errors ) {
# do error handling
}

For small CGI scripts, its common to get a parameter, untaint it, pass it to an object constructor and get the object back. This module would allow one to to build Class::CGI handler classes which take the parameter value, automatically perform those steps and just return the object. Much grunt work goes away and you can get back to merely pretending to work.

Class::Maker Perl module contains classes, reflection, schema, serialization, attribute- and multiple inheritance.

SYNOPSIS

use Class::Maker qw(class);
class Human, { isa => [qw( ParentClass )],
public =>
{
string => [qw(name lastname)],

ref => [qw(father mother)],

array => [qw(friends)],

custom => [qw(anything)],
},

private =>
{
int => [qw(dummy1 dummy2)],
},

configure =>
{
ctor => create,

explicit => 0,
},
};
sub Human::greeting : method { my $this = shift;
printf This is %s (%d), $this->name, $this->uid;
}
class UnixUser, { isa => [qw( Human )],
public =>
{
int => [qw(uid gid)],

string => [qw(username)],
},
};

my $a = Human->new( uid => 1, gid => 2, name => Bart );

$a->father( Human->new( name => Houmer ) );

$a->greeting();

$a->uid = 12;

$a->_dummy1( bla );

Class::Maker introduces the concept of classes via a "class" function. It automatically creates packages, ISA, new and attribute-handlers. The classes can inherit from common perl-classes and class-maker classes. Single and multiple inheritance is supported.

This package is for everybody who wants to program oo-perl and does not really feel comfortable with the common way.

Java-like reflection is also implemented and allows one to inspect the class properties and methods during runtime. This is helpfull for implementing persistance and serialization. A Tangram (see cpan) schema generator is included to the package, so one can use Tangram object-persistance on the fly as long as he uses Class::Maker classes.