Free class maker 0.05.18 software for linux

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.

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";

File::Maker is a Perl module that mimics a make by loading a database and calling targets methods.

SYNOPSIS

#####
# Subroutine interface
#
use File::Maker qw(load_db);

%data = load_db($pm);

######
# Object interface
#
require File::Maker;

$maker = $maker->load_db($pm);

$maker->make_targets(%targets, @targets, %options );
$maker->make_targets(%targets, %options );

$maker = new File::Maker(@options);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

When porting low level C code from one architecture to another, makefiles do provide some level of automation and save some time. However, once Perl or another high-level language is up and running, the high-level language usually allows much more efficient use of programmers time; otherwise, whats point of the high-level language. Thus, makes great economically sense to switch from makefiles to high-level language.

The File::Maker program module provides a "make" style interface as shown in the herein above. The @targets contains a list of targets that mimics the targets of a makefile. The targets are subroutines written in Perl in a separate program module from the File::Maker. The separate target program module inherits the methods in the File::Maker program module as follows:

use File::Maker;
use vars qw( @ISA );
@ISA = qw(File::Maker);

The File::Maker methods will then find the target subroutines in the separate target program module.

The File::Maker provides for the loading of a hash from a program module to provide for the capabilities of defines in a makefile. The option pm = $file> tells File::Maker to load a database from the __DATA__ section of a program module that is in the Tie::Form format. The Tie::Form format is a very flexible lenient format that is about as close to a natural language form and still have the precision of being machine readable.

This provides a more flexible alternative to the defines in a makefile. The define hash is in a separate, very flexible form program module. This arrangement allows one target program module that inherits the File::Maker program module to produce as many different outputs as there are Tie::Form program modules.

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.

Patch Maker helps you manage multiple in-progress source code patches to software. Patch Maker remembers which files are part of which patch, and keeps them disentangled during the development process.
It speeds up common operations and housekeeping tasks, allowing you to focus on writing code. It is a command-line tool written in Perl, and so is usable on (at least) Windows, Linux and Mac OS X.
Enhancements:
- Initial SVN support was added to go with CVS.
- The configuration was moved to the .pmrc file in the home directory.
- Message and error printing were tidied up and standardized.

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.

Soundboard Maker is a tool for making and running soundboards.

You can play selected audio, save soundboards, load soundboards, and distribute your soundboards to other users.

The interface is easy to customize.

Class.Jabber.PHP provides a medium-level API to interact with the Jabber network.

Class.Jabber.PHP is a class which you can use to connect to the Jabber network. It allows you to easily connect to a server and interact with it. It supports all packet types (message, iq, and presence), is very flexible, and offers both high-level methods (registration, message sending, etc.) and low-level methods (packet sending, etc.).

The problem with current IM solutions is that they are all proprietary and cannot talk to each other. Jabber seeks to get rid of those barriers by allowing a Jabber client to talk with an AOL user, or an IRC chat room, or any number of other programs.

Class.Jabber.PHP a PHP class that provides a PHP Developer access to the Jabber protocol. Using this OOP class, I provide a clean interface to writing anything from a full client to a simple protocol tester.