Free class software for linux

Class::Generate is a Perl module that can generate Perl class hierarchies.

SYNOPSIS

use Class::Generate qw(class subclass delete_class);

# Declare class Class_Name, with the following types of members:
class
Class_Name => [
s => $, # scalar
a => @, # array
h => %, # hash
c => Class, # Class
c_a => @Class, # array of Class
c_h => %Class, # hash of Class
&m => body, # method
];

# Allocate an instance of class_name, with members initialized to the
# given values (pass arrays and hashes using references).
$obj = Class_Name->new ( s => scalar,
a => [ values ],
h => { key1 => v1, ... },
c => Class->new,
c_a => [ Class->new, ... ],
c_h => [ key1 => Class->new, ... ] );

# Scalar type accessor:
$obj->s($value); # Assign $value to member s.
$member_value = $obj->s; # Access members value.

# (Class) Array type accessor:
$obj->a([value1, value2, ...]); # Assign whole array to member.
$obj->a(2, $value); # Assign $value to array member 2.
$obj->add_a($value); # Append $value to end of array.
@a = $obj->a; # Access whole array.
$ary_member_value = $obj->a(2); # Access array member 2.
$s = $obj->a_size; # Return size of array.
$value = $obj->last_a; # Return last element of array.

# (Class) Hash type accessor:
$obj->h({ k_1=>v1, ..., k_n=>v_n }) # Assign whole hash to member.
$obj->h($key, $value); # Assign $value to hash member $key.
%hash = $obj->h; # Access whole hash.
$hash_member_value = $obj->h($key); # Access hash member value $key.
$obj->delete_h($key); # Delete slot occupied by $key.
@keys = $obj->h_keys; # Access keys of member h.
@values = $obj->h_values; # Access values of member h.

$another = $obj->copy; # Copy an object.
if ( $obj->equals($another) ) { ... } # Test equality.

subclass s => [ ], -parent => class_name;

The Class::Generate package exports functions that take as arguments a class specification and create from these specifications a Perl 5 class. The specification language allows many object-oriented constructs: typed members, inheritance, private members, required members, default values, object methods, class methods, class variables, and more.

CPAN contains similar packages. Why another? Because object-oriented programming, especially in a dynamic language like Perl, is a complicated endeavor. I wanted a package that would work very hard to catch the errors you (well, I anyway) commonly make. I wanted a package that could help me enforce the contract of object-oriented programming. I also wanted it to get out of my way when I asked.

Class::Simple is a simple Object-Oriented Base Class.

SYNOPSIS

package Foo:
use base qw(Class::Simple);

BEGIN
{
Foo->privatize(qw(attrib1 attrib2)); # ...or not.
}
my $obj = Foo->new();

$obj->attrib(1); # The same as...
$obj->set_attrib(1); # ...this.

my $var = $obj->get_attrib(); # The same as...
$var = $obj->attrib; # ...this.

$obj->raise_attrib(); # The same as...
$obj->set_attrib(1); # ...this.

$obj->clear_attrib(); # The same as...
$obj->set_attrib(undef); # ...this
$obj->attrib(undef); # ...and this.

$obj->readonly_attrib(4);

sub foo
{
my $self = shift;
my $value = shift;

$self->_foo($value);
do_other_things(@_);
...
}

my $str = $obj->DUMP;
my $new_obj = Foo->new();
$new_obj->SLURP($str);

sub BUILD
{
my $self = shift;

# Various initializations
}

There are plenty of others that are much more thorough and whatnot but sometimes I want something simple so I can get just going (no doubt because I am a simple guy) so I use this.

What do I mean by simple? First off, I dont want to have to list out all my methods beforehand. I just want to use them (Yeah, yeah, it doesnt catch typos--thats what testing and Class::Std are for :-). Next, I want to be able to call my methods by $obj->foo(1) or $obj->set_foo(1), by $obj->foo() or $obj->get_foo(). Dont tell ME I have to use get_ and set_ (I would just override that restriction in Class::Std anyway). Simple!

I did want some neat features, though, so these are inside-out objects (meaning the object isnt simply a hash so you cant just go in and muck with attributes outside of methods), privatization of methods is supported, as is serialization out and back in again.

Class::DispatchToAll Perl module can dispatch a method call to all inherited methods.

SYNOPSIS

package My::Class;
our @ISA=qw(SomeClass SomeOtherClass More::Classes);
use Class::DispatchToAll qw(dispatch_to_all);

my $self=bless {},My::Class # not a proper constructor, I know..

# this calls some_method in all Classes My::Class inherits from
# and all classes those classes inherit from, and all ... you get
# the point.
$self->dispatch_to_all(some_method);

# saves all return values from all calls in an array
my @returns=$self->dispatch_to_all(some_method);

See the Docs of Damian Conways Module Class::Delegation for a good introduction about Dispatching vs. Inheritance.

Class::DispatchToAll enables you to call all instantances of a method in your inheritance tree (or labyrinth..).

The standard Perl behaviour is to call only the lefternmost instance it can fing doing a depth first traversial.

Imagine the following class structure:
C
/
A B C::C
/ /
A::A D
/
My::Class

Perl will try to find a method in this mess in this order:

My::Class -> A::A -> A -> B -> D -> B -> C::C -> C
(Note that it will look twice in B because B is a parent of both A::A and D))

As soon as Perl finds the method somewhere, it will short-circuit out of its search and invoke the method.

And that is exactly the behaviour Class::DispatchToAll changes.

If you use dispatch_to_all (provided by Class::DispatchToAll) to call your method, Perl will look in all of the aforementioned packages and run all the methods it can find. It will even collect all the return values and return them to you as an array, if you want it too.

Class::IntrospectionMethods::Catalog can manage catalogs from IntrospectionMethods.

Exported functions

set_method_info( target_class, method_name, info_ref )

Store construction info for method method_name of class target_class.

set_global_catalog (target_class, ...)

Store catalog informations. The first parameter is the class featuring the methods declared in the global catalog.

Following paramaters is a set of named paramaters (e.g. key => value):

name

Mandatory name for the global catalog

list

array ref containing the list of slot and catalog. E.g.:

list => [
[qw/foo bar baz/] => foo_catalog,
[qw/a b z/] => alpha_catalog,
my_object => my_catalog
],
isa

Optional hash ref declaring a containment for catalog. E.g:

list => [ foo => USER ,
admin => ROOT ],
isa => { USER => ROOT }

Then the ROOT catalog will return foo, and the USER catalog will return foo and admin.

help

Optional hash ref (slot_name => help). Store some help information for each slot.

set_global_catalog will construct:

A ClassCatalog object containing the global catalog informations.

A sub_ref containing the ClassCatalog object in a closure.

Returns ( slot_name, sub_ref ). The sub_ref is to be installed in the target class.

When called as a class method, the subref will return the ClassCatalog object. When called as a target class method, the subref will return an ObjectCatalog object associated to the ClassCatalog object stored in the closure.

These 2 object have the same API. ObjectCatalog is used to contain catalog changes that may occur at run-time. ClassCatalog informations will not change.

Class::Classgen::New is a Perl module that creates the new() method for classes generated by classgen.

SYNOPSIS

Used within classgen.

The main purpose of New.pm is to write the new() method for a class generated by classgen. It provides code to derive local instance variables with my for all specified instance variables. It provides code to store them within an anonymous hash (only way in the current version). Finally, this hash is blessed into the desired class.

Methods generated by New.pm

In the blessing section of the generated new() method:
inherit_from(): copies the entries of the blessed {} from the base class into the blessed {} of the derived class.

ENVIRONMENT

Nothing special. Just use Perl5.

DIAGNOSTICS

There is no special diagnostics. New.pm is used within classgen which is called with the -w option.

Class::Adapter is a Perl implementation of the "Adapter" Design Pattern.

The Class::Adapter class is intended as an abstract base class for creating any sort of class or object that follows the Adapter pattern.

What is an Adapter?

The term Adapter refers to a "Design Pattern" of the same name, from the famous "Gang of Four" book "Design Patterns". Although their original implementation was designed for Java and similar single-inheritance strictly-typed langauge, the situation for which it applies is still valid.

An Adapter in this Perl sense of the term is when a class is created to achieve by composition (objects containing other object) something that cant be achieved by inheritance (sub-classing).

This is similar to the Decorator pattern, but is intended to be applied on a class-by-class basis, as opposed to being able to be applied one object at a time, as is the case with the Decorator pattern.

The Class::Adapter object holds a parent object that it "wraps", and when a method is called on the Class::Adapter, it manually calls the same (or different) method with the same (or different) parameters on the parent object contained within it.

Instead of these custom methods being hooked in on an object-by-object basis, they are defined at the class level.

Basically, a Class::Adapter is one of your fall-back positions when Perls inheritance model fails you, or is no longer good enough, and you need to do something twisty in order to make several APIs play nicely with each other.

What can I do with the actual Class::Adapter class

Well... nothing really. It exist to provide some extremely low level fundamental methods, and to provide a common base for inheritance of Adapter classes.
The base Class::Adapter class doesnt even implement a way to push method calls through to the underlying object, since the way in which that happens is the bit that changes from case to case.

To actually DO something, you probably want to go take a look at Class::Adapter::Builder, which makes the creation of Adapter classes relatively quick and easy.

Class::Declare is a Perl module created to declare classes with public, private and protected attributes and methods.

SYNOPSIS

package My::Class;

use strict;
use warnings;
use base qw( Class::Declare );

__PACKAGE__->declare(

public => { public_attr => 42 } ,
private => { private_attr => Foo } ,
protected => { protected_attr => Bar } ,
class => { class_attr => [ 3.141 ] }
static => { static_attr => { a => 1 } } ,
restricted => { restricted_attr => string } ,
abstract => abstract_attr ,
friends => main::trustedsub ,
new => [ public_attr , private_attr ] ,
init => sub { # object initialisation
...
1;
} ,
strict => 0

);

sub publicmethod {
my $self = __PACKAGE__->public( shift );
...
}

sub privatemethod {
my $self = __PACKAGE__->private( shift );
...
}

sub protectedmethod {
my $self = __PACKAGE__->protected( shift );
...
}

sub classmethod {
my $self = __PACKAGE__->class( shift );
...
}

sub staticmethod {
my $self = __PACKAGE__->static( shift );
...
}

sub restrictedmethod {
my $self = __PACKAGE__->restricted( shift );
...
}

sub abstractmethod { __PACKAGE__->abstract }

1;

...

my $obj = My::Class->new( public_attr => fish );

MOTIVATION

One of Perls greatest strengths is its flexible object model. You can turn anything (so long as its a reference, or you can get a reference to it) into an object. This allows coders to choose the most appropriate implementation for each specific need, and still maintain a consistent object oriented approach.
A common paradigm for implementing objects in Perl is to use a blessed hash reference, where the keys of the hash represent attributes of the class. This approach is simple, relatively quick, and trivial to extend, but its not very secure. Since we return a reference to the hash directly to the user they can alter hash values without using the classs accessor methods. This allows for coding "short-cuts" which at best reduce the maintainability of the code, and at worst may introduce bugs and inconsistencies not anticipated by the original module author.

On some systems, this may not be too much of a problem. If the developer base is small, then we can trust the users of our modules to Do The Right Thing. However, as a modules user base increases, or the complexity of the systems our modules are embedded in grows, it may become desirable to control what users can and cant access in our module to guarantee our codes behaviour. A traditional method of indicating that an objects data and methods are for internal use only is to prefix attribute and method names with underscores. However, this still relies on the end user Doing The Right Thing.

Class::Declare provides mechanisms for module developers to explicitly state where and how their class attributes and methods may be accessed, as well as hiding the underlying data store of the objects to prevent unwanted tampering with the data of the objects and classes. This provides a robust framework for developing Perl modules consistent with more strongly-typed object oriented languages, such as Java and C++, where classes provide public, private, and protected interfaces to object and class data and methods.