Free constructor software for linux

Boa Constructor is a cross platform Python IDE and wxPython GUI Builder. It offers visual frame creation and manipulation, an object inspector, many views on the source like object browsers, inheritance hierarchies, doc string generated html documentation, an advanced debugger and integrated help.
Zope support: Object creation and editing. Cut, copy, paste, import and export. Property creation and editing in the Inspector and Python Script debugging.
It is written in Python and uses the wxPython library which wraps wxWindows.
Python is an interpreted, interactive, object-oriented programming language. It is often compared to Tcl, Perl, Scheme or Java.
Python combines remarkable power with very clear syntax. It has modules, classes, exceptions, very high level dynamic data types, and dynamic typing. There are interfaces to many system calls and libraries, and new built-in modules are easily written in C or C++. Python is also usable as an extension language for applications that need a programmable interface.
wxPython is a Python extension module that encapsulates the wxWindows GUI classes. Currently it is available for the Win32 and GTK ports of wxWindows, but as soon as the other ports are brought up to the same level as Win32 and GTK, it should be fairly trivial to enable wxPython to be used with the new GUI.
Enhancements:
- Primarily a bugfix release for compatibility with the latest wxPython.

Peco::Container is a light inversion of Control (IoC) container.

SYNOPSIS

my $c = Peco::Container->new;

$c->register( my_key, My::Class );
$c->register( my_key, My::Class, [ @deps ] );
$c->register( my_key, My::Class, [ @deps ], create );
$c->register( my_key, My::Class, [ @deps ], create, { %attrs } );

$c->register( my_key, My::Class, undef, create );
$c->register( my_key, My::Class, undef, create, { %attrs } );
$c->register( my_key, My::Class, [ @deps ], undef, { %attrs } );

my $instance = $c->get(my_key);
my @instances = $c->get_all();

$c->has(my_key) ? 1 : 0;
$c->is_empty ? 1 : 0;

$c->multicast( method, @args );

Peco::Container is a small, flexible Inversion of Control (IoC) container supporting both Constructor Injection and Setter Injection patterns, as well prototype services (factories) and multicasting.

Net::BGP::Router is a BGP Router based on Net::BGP.

SYNOPSIS

use Net::BGP::Router;
# Constructor
$router = new Net::BGP::Router(
Name => My very own router!,
Policy => new Net::BGP::Policy
);
# Accessor Methods
$router->add_peer($peer,both,$acl);
$router->remove_peer($peer,both);
$router->set_policy($policy);
$router->set_policy($peer,in,$acl);
__top

This module implement a BGP router. It uses Net::BGP objects for the BGP sessions and a Net::BGP::RIB object to store the routes. Policy are handled using a Net::BGP::Policy object.

Class::Container is a Perl module with Glues object frameworks together transparently.

SYNOPSIS

package Car;
use Class::Container;
@ISA = qw(Class::Container);

__PACKAGE__->valid_params
(
paint => {default => burgundy},
style => {default => coupe},
windshield => {isa => Glass},
radio => {isa => Audio::Device},
);

__PACKAGE__->contained_objects
(
windshield => Glass::Shatterproof,
wheel => { class => Vehicle::Wheel,
delayed => 1 },
radio => Audio::MP3,
);

sub new {
my $package = shift;

# windshield and radio objects are created automatically by
# SUPER::new()
my $self = $package->SUPER::new(@_);

$self->{right_wheel} = $self->create_delayed_object(wheel);
... do any more initialization here ...
return $self;
}

This class facilitates building frameworks of several classes that inter-operate. It was first designed and built for HTML::Mason, in which the Compiler, Lexer, Interpreter, Resolver, Component, Buffer, and several other objects must create each other transparently, passing the appropriate parameters to the right class, possibly substituting other subclasses for any of these objects.

The main features of Class::Container are:

Explicit declaration of containment relationships (aggregation, factory creation, etc.)
Declaration of constructor parameters accepted by each member in a class framework
Transparent passing of constructor parameters to the class that needs them
Ability to create one (automatic) or many (manual) contained objects automatically and transparently

SWIFT::Factory::BasicHeader is a Perl module that provides a Basic Header Block (Block 1) for a SWIFT message.

SYNOPSIS

use SWIFT::Factory::BasicHeader;
my $hdr1=SWIFT::Factory::BasicHeader->new();

This module is primarily intended to be used by the different SWIFT::Factory::MTnnn modules to provide full SWIFT messages for input to the SWIFT network.

Nevertheless, there is nothing prohibiting an application to directly use this module for whatever purpose.

Given reasonable parameter values in the constructor, the string method in this module will return a Basic Header Block (Block nbr 1) that can be used in a SWIFT message sent to the SWIFT network.

CONSTRUCTOR

new( APPLICATION_ID=>F, SERVICE_ID=>1, BIC=>VALIDBIC, TERMINAL=>X, BRANCH_CODE=>XXX, SESSION_NBR=>0, INPUT_SEQUENCE_NBR=>0)

The parameters may be given in arbitrary order. Many parameters have builtin default values. If the calling application doesnt provide the parameter at all, the object will apply the default value.

APPLICATION_ID=>

Optional. A one character value that indicates the application within which the message is being sent.

Valid values are:

F (FIN = All user-to-user, FIN system and FIN system msgs),
A (GPA = Most GPA system mesgs)
and
L (Certain GPA msgs, for ex. LOGIN).

Default value: F, which is the most commonly used application.

To set this value, use one of:

SWIFT::Factory::BasicHeader->APP_ID_FIN,
SWIFT::Factory::BasicHeader->APP_ID_GPA,
and
SWIFT::Factory::BasicHeader->APP_ID_GPA_LOG.

Yes, these are constants, and yes, since they are class methods they are available before calling the constructor.

Opposit of the object methods that are functional only after having called the new() constructor.

SERVICE_ID=>

Optional. A numeric value that identifies the type of data that is being sent. Maximum two characters long. See the relevant SWIFT handbook for details.
Default value: 1, which will output as 01.

BIC=>

Technically optional, but it will probably quite rarely make sense to instantiate an object of this class without specifying a BIC. An eight character value that contains a valid receiver BIC.

TERMINAL=>

Optional. A one character value that identifies the receiving terminal.
Default value: X.

BRANCH_CODE=>

Optional. A three character value that identifies the branch code at the receiver.
Default value: XXX.

SESSION_NBR=>

Optional. A numeric value. Maximum four characters long. See the relevant SWIFT handbook for details.

Default value: 0, which will output as 0000.

INPUT_SEQUENCE_NBR=>

Optional. A numeric value. Maximum six characters long. See the relevant SWIFT handbook for details.

Default value: 0, which will output as 000000.

ExtUtils::ModuleMaker is a Perl module better than h2xs for creating modules.

SYNOPSIS

At the command prompt:
% modulemaker
Inside a Perl program:
use ExtUtils::ModuleMaker;

$mod = ExtUtils::ModuleMaker->new(
NAME => Sample::Module
);

$mod->complete_build();

$mod->dump_keys(qw|
... # key provided as argument to constructor
... # same
|);

$mod->dump_keys_except(qw|
... # key provided as argument to constructor
... # same
|);

$license = $mod->get_license();

$mod->make_selections_defaults();

This module is a replacement for the most typical use of the h2xs utility bundled with all Perl distributions: the creation of the directories and files required for a pure-Perl module to be installable with make and distributable on the Comprehensive Perl Archive Network (CPAN).
h2xs has many options which are useful -- indeed, necessary -- for the creation of a properly structured distribution that includes C code as well as Perl code. Most of the time, however, h2xs is used as follows

% h2xs -AXn My::Module

to create a distribution containing only Perl code. ExtUtils::ModuleMaker is intended to be an easy-to-use replacement for this use of h2xs.

While you can call ExtUtils::ModuleMaker from within a Perl script (as in the SYNOPSIS above), its easier to use with a command-prompt invocation of the modulemaker script bundled with this distribution:

% modulemaker

Then respond to the prompts. For Perl programmers, laziness is a virtue -- and modulemaker is far and away the laziest way to create a pure Perl distribution which meets all the requirements for worldwide distribution via CPAN.

Test::Unit::Runner::XML is a Perl module that can generate XML reports from unit test results.

SYNOPSIS

use Test::Unit::Runner::XML;

mkdir("test_reports");
my $runner = Test::Unit::Runner::XML->new("test-reports");
$runner->start($test);
exit(!$runner->all_tests_passed());

Test::Unit::Runner::XML generates XML reports from unit test results. The reports are in the same format as those produced by Ants JUnit task, allowing them to be used with Java continuous integration and reporting tools.

CONSTRUCTOR

Test::Unit::Runner::XML->new($directory)
Construct a new runner that will write XML reports into $directory

METHODS

start

$runner->start($test);

Run the Test::Unit::Test $test and generate XML reports from the results.

all_tests_passed

exit(!$runner->all_tests_passed());

Return true if all tests executed by $runner since it was constructed passed.