Free parameters software for linux

Perl6::Parameters is a module with Perl 6-style prototypes with named parameters.

SYNOPSIS

use Perl6::Parameters;

sub mysub($foo, ARRAY $bar, *%rest) {
...
}

DETAILS

Perl6::Parameters is a Perl module which simulates Perl 6s named parameters. (When I talk about "named parameters" I mean something like the parameters youre used to from C, Java and many other languages--not pass-a-hash-with-the-parameters-in-it things.)

Like most other programming languages, Perl 6 will support subroutines with pre-declared variables the parameters are put into. (Using this will be optional, however.) This goes far beyond the "line-noise prototypes" available in Perl 5, which only allow you to control context and automatically take references to some parameters--lines like my($first, $second)=(@_) will no longer be necessary.

Although Perl 6 will have this, Perl 5 doesnt; this module makes it so that Perl 5 does. It uses some other Perl 6-isms too, notably the names for builtin types and the unary-asterisk notation for flattening a list.

Crafting Parameter Lists

Crafting parameter lists is simple; just declare your subroutine and put the parameters separated by commas or semicolons, in parenthesis. (Using a semicolon signifies that all remaining parameters are optional; this may not be available this way in Perl 6, but Im assuming it is until I hear otherwise.)

Most parameters are just variable names like $foo; however, more sophisticated behavior is possible. There are three ways to achieve this.

The first way is by specifying a type for the variable. Certain types make the actual parameters turn into references to themselves:

ARRAY $foo

This turns an array into a reference to itself and stores the reference into $foo.

HASH $foo

This turns a hash into a reference to itself and stores the reference into $foo.

CODE $foo

This turns a subroutine into a reference to itself and stores the reference into $foo.

SCALAR $foo

This turns a scalar into a reference to itself and stores the reference into $foo.

GLOB $foo

This turns a typeglob into a reference to itself and stores the reference into $foo. Typeglobs will be going away in Perl 6; this type exists in this module so that its useful for general use in Perl 5.

REF $foo

This turns any parameter into a reference to itself and stores it into $foo.

This only works in Perl 5.8. Otherwise, its treated the same as any other unrecognized type name.

AnythingElse $foo

This has no effect in this module; its treated as though youd typed $foo without the AnythingElse.

For example, if a subroutine had the parameters ($foo, HASH $bar, CODE $baz) and was called with ($scalar, %hash, &mysub) the subroutine would get the contents of $scalar, a reference to %hash and a reference to &mysub.
The second way is by supplying an actual array or hash as a parameter name. This requires an array or hash to be passed in for that parameter; it preserves the length of the array or hash.

The final way is only available for the last parameter: if an array or hash is prefixed with an asterisk, that array or hash will be filled with any additional parameters.

Params::Validate is a Perl module to validate method/function parameters.

SYNOPSIS

use Params::Validate qw(:all);

# takes named params (hash or hashref)
sub foo
{
validate( @_, { foo => 1, # mandatory
bar => 0, # optional
}
);
}

# takes positional params
sub bar
{
# first two are mandatory, third is optional
validate_pos( @_, 1, 1, 0 );
}


sub foo2
{
validate( @_,
{ foo =>
# specify a type
{ type => ARRAYREF },

bar =>
# specify an interface
{ can => [ print, flush, frobnicate ] },

baz =>
{ type => SCALAR, # a scalar ...
# ... that is a plain integer ...
regex => qr/^d+$/,
callbacks =>
{ # ... and smaller than 90
less than 90 => sub { shift() < 90 },
},
}
}
);
}

sub with_defaults
{
my %p = validate( @_, { foo => 1, # required
# $p{bar} will be 99 if bar is not
# given. bar is now optional.
bar => { default => 99 } } );
}

sub pos_with_defaults
{
my @p = validate_pos( @_, 1, { default => 99 } );
}

sub sets_options_on_call
{
my %p = validate_with
( params => @_,
spec => { foo => { type SCALAR, default => 2 } },
normalize_keys => sub { $_[0] =~ s/^-//; lc $_[0] },
);
}

The Params::Validate module allows you to validate method or function call parameters to an arbitrary level of specificity. At the simplest level, it is capable of validating the required parameters were given and that no unspecified additional parameters were passed in.

It is also capable of determining that a parameter is of a specific type, that it is an object of a certain class hierarchy, that it possesses certain methods, or applying validation callbacks to arguments.

SPWrapper project analyzes Oracle database system tables, finds out parameter names and types, and writes the Java code necessary for calling stored procedures.
Do you ever needed to use stored procedures from java code? Perhaps you had to write first the stored procedure, then you had to write that boring java code with all those register parameters and getInt/getString etc.
Then perhaps you needed to change some parameters and had to check and correct the java code. And what about double checking that the connection was closed and the exception catched in the right way?
I had to do it a lot of times... then I realized that once you have written and compiled the stored procedure in you database all the needed information about parameters is available. A program could read this information and write for me the needed java code.
SPWrapper is the result of this idea. Currently it works with the Oracle database, but in the future I plan support other databases.
Enhancements:
- Now SPWrapper is able to create stored procedure wrappers also for SqlServer, Mysql and Postgresql

sdp2rat is a Perl script that parses SDP files and launches RAT with the parameters found in the file. The SDP file can either be a file on local disk or a URL. sdp2rat now uses the Net::SDP perl module and the latest version is available as part of that package.
Enhancements:
- Opens SDP files as URLs as well as on disk

Particle Simulation project is a simulation of spraying up to 60k particles in realtime.
Particle Simulation is a playful simulation game which allows you to spray particles into the "air". The number of simulated particles is only limited by the speed of your computer.
The particles dont interact with each other, but will bounce back from the ground and accelerate depending on a gravity constant.
This constant can be changed (along with a number of other parameters) in the source code or via commandline parameters.
Enhancements:
- Colors were adjusted and a new animation mode was introduced.
- Segmentation fault was fixed.

Sdp PARser is the conferencing utility. New multicast capable multimedia applications, such as RealPlayer and Marratech Pro, can accept files containing session descriptions (in SDP format) to join a multicast conference. This allows SDP files to be served from a web page and a conference joined, using a registered SDP MIME type associated with the application.

Alternatively popular MBone applications, such as VIC, RAT, WB and NTE rely on the Session Directory Tool (SDR) to convert the SDP into command line parameters and thus cannot take advantage of joining conferences via a web page. The solution offered here is to accept the SDP from the web browser, convert it to command line parameters at the client side and then to start up the tools with the relevant parameters. This could be implemented in several possible ways:

* a platform dependent binary running on the client machine with a MIME type for the SDP
* a plug-in installed in the browser
* a Java applet with execution privileges

The Java applet was implemented because it doesnt requiere a installation or configuration by the user and is platform independent.

FrameNet::WordNet::Detour is a WordNet to FrameNet Detour.

SYNOPSIS

use FrameNet::WordNet::Detour;

# Creation without parameters, $WNHOME and $FNHOME will be used
my $detour = FrameNet::WordNet::Detour->new;

# Creation with some parameters
my $detour2 = FrameNet::WordNet::Detour->new(-wnhome => /path/to/WordNet,
-fnhome => /path/to/FrameNet
-cached => 1,
-limited => undef);

my $result = $detour->query("walk#v#1");

if ($result->is_ok) {
print "Best frames: n";
print join( , @{$result->get_best_framenames})."n";

print "All frames: n";
print join( , @{$result->get_all_framenames})."n";

print "All frames with weights: n";
foreach my $frame (@{$result->get_all_frames}) {
print $frame->name.": ";
print $frame->get_weight."n";
}
} else {
print $result->message."n";
}