Free maker 0.05 software for linux

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.

mod_arm provides a simple, seamless, and application independent interface to ARM (Application Response Measurement).

mod_arm allows system administrators to get an accurate idea of how long an application takes on a running server - for a single instance or as a step in a multi-tier transaction. This is definitely a work in progress.

Configuration Directives

Arm

Syntax: Arm state
When state is on, ARM measurements will be taken for this directory
When state is application, ARM measurements will be controlled by the application scripting language such as PHP (not yet implemented)
When state is off, no measurements are taken for this directory

ArmApplication

Syntax: ArmApplication application_name
Specifies the application name to use for this directory. If non is specified, the default value of "Apache" is used.

ArmUser

Syntax: ArmUser user_name
Specifies the user name for the transaction. If none is specified, the default value of "*" is used

ArmTransaction

Syntax: ArmTransaction transaction_name
Specifies the name of the transaction. If none is specified, the default value will be the URI of the object requested.

ArmTransactionInfo

Syntax: ArmTransactionInfo transaction_info
This is an informational string used to descibe the transaction, primarily for use by transaction correlators. If not specifed, the default value is "Apache web page".

Aorta project is a load-balancing clustered P2P application.
It executes Tasklets (which have the ability to split themselves into sub tasks that can be executed in pararell).
A typical cluster contains of a LAN with 1-256 computers, each one running aorta.
A Tasklet can be of any type ranging from encoding MP3s, Genomic DNA Alignment, or simply to rendering Web pages for high speed/heavily loaded Web sites.
You can make functions calls to C/C++, applications like Matlab, etc.
Main features:
- PingTasklet simply traversers your net of aortas.
- ImageTasklet , simply rescale imagecolours.
- EncodeTasklet, spreads out mp3 encode in your LAN.
- SimpleSort , Merge sort by Gretsam.
Enhancements:
- Refactored to one base class Moblet,the smalles code and data entity moving around
- Improved Moblet Receiver and executing. Minimizing worker idle time
- startup script aorta.sh improved now can start with remote debug params
- Aorta core can now be used as an API to emit/delegete Moblets from an user created application
- Preferences stuff should work on a MS platform now
- Herve added DocBook to buildsystem
- Gretsam added a MergeSorter Tasklet

List::Maker is a Perl module that can generate more sophisticated lists than just $a..$b.

SYNOPSIS

use List::Maker;

@list = < 1..10 >; # (1,2,3,4,5,6,7,8,9,10)

@list = < 10..1 >; # (10,9,8,7,6,5,4,3,2,1)

@list = < 1,3,..10 > # (1,3,5,7,9)
@list = < 1..10 x 2 > # (1,3,5,7,9)

@list = < 0..10 : prime N >; # (2,3,5,7)
@list = < 1,3,..30 : /7/ > # (7,17,27)

@words = < a list of words >; # (a, list, of, words)
@words = < a list "of words" >; # (a list, of words)

The List::Maker module hijacks Perls built-in file globbing syntax (< *.pl > and glob *.pl) and retargets it at list creation.

The rationale is simple: most people rarely if ever glob a set of files, but they have to create lists in almost every program they write. So the list construction syntax should be easier than the filename expansion syntax.

Config Maker is a tool to automatically create C++ classes that parse configuration files.

Only a few lines of text that describe the possible entries in the configuration file are needed, and the complete class will be generated ready for use.

Basic usage

The input files for Config Maker have a very simple structure (in ANTLR/grep like notation):

objectname (configentry)+
Each configentry looks like this
type entryname defaultvalue (comment)?

type

Type of the entry, can be int, double, string or bool. If the basic type is followed by any number, the corresponding c++object variable will be of type vector < basic type > The number is the initial number of elements that are allocated for the vector, but the actual configuration file can contain more components. These are added using the push_back method.

If there are less elements specified in the configuration file, the object variable will still contain the number of elements specified here. No warning will be issued.
configentry

Name of the entry and corresponding variable. Has to be at least two characters long and can contain characters and numbers. Case insensitive.

defaultvalue

Default value for the entry. This is optional.

comment

Each comment starts with // and is completely ignored

Tk::HyperText can create and manipulate ROText widgets which render HTML code.

SYNOPSIS

my $hypertext = $mw->Scrolled ("HyperText",
-scrollbars => e,
-wrap => word,
-linkcommand => &onLink, # what to do when links are clicked
-titlecommand => &onTitle, # what to do when

Gtk2::TrayManager is a Perl bindings for EggTrayManager.

SYNOPSIS

use Gtk2 -init;
use Gtk2::TrayManager;

my $screen = Gtk2::Gdk::Screen->get_default;

if (Gtk2::TrayManager->check_running($screen)) {
print STDERR "A tray manager is already running, sorry!n";
exit 256;
}

my $tray = Gtk2::TrayManager->new;
$tray->manage_screen($screen);
$tray->set_orientation(vertical);

$tray->signal_connect(tray_icon_added, sub {
# $_[1] is a Gtk2::Socket
});

$tray->signal_connect(tray_icon_removed, sub {
# $_[1] is a Gtk2::Socket
});

The EggTrayManager library is used internally by GNOME to implement the server-side of the Notification Area (or system tray) protocol. Gtk2::TrayManager allows you to create notification area applications using Gtk2-Perl.

Tie::Trace can easy print debugging with tie.

SYNOPSIS

use Tie::Trace;

my %hash;
tie %hash, "Tie::Trace";

$hash{hoge} = hogehoge; # warn Hash => Key: hoge, Value: hogehgoe at ...

my @array;
tie @aray, "Tie::Trace";
push @array, "array"; # warn Array => Point: 0, Value: array at ...

my $scalar;
tie $scalar, "Tie::Trace";
$scalar = "scalar"; # warn Scalar => Value: scalar at ...

This is usefull for print debugging. Using tie mechanism, you can see sotred value for the specified variable.

If the stored value is scalar/array/hash ref, this can check recursively.

for example;
tie %hash, "Tie::Trace";

$hash{foo} = {a => 1, b => 2}; # warn ...
$hash{foo}->{a} = 2 # warn ...

But This ignores blessed reference and tied value.