Free type 1 software for linux

Hash::Type module contains pseudo-hashes as arrays tied to a "type" (list of fields).

SYNOPSIS

use Hash::Type;

# create a Hash::Type
my $personType = new Hash::Type(qw(firstname lastname city));

# create and populate some hashes tied to $personType
tie %wolfgang, $personType, "wolfgang amadeus", "mozart", "salzburg";
$ludwig = new $personType ("ludwig", "van beethoven", "vienna");
$jsb = new $personType;
$jsb->{city} = "leipzig";
@{$jsb}{qw(firstname lastname)} = ("johann sebastian", "bach");

# add fields dynamically
$personType->add("birth", "death") or die "fields not added";
$wolfgang{birth} = 1750;

# More complete example : read a flat file with headers on first line
my ($headerline, @datalines) = map {chomp; $_} ;
my $ht = new Hash::Type(split /t/, $headerline);
foreach my $line (@datalines) {
my $data = new $ht(split /t/, $line);
work_with($data->{someField}, $data->{someOtherField});
}

# an alternative to Time::gmtime and Time::localtime
my $timeType = new Hash::Type qw(sec min hour mday mon year wday yday);
my $localtime = new $timeType (localtime);
my $gmtime = new $timeType (gmtime);
print $localtime->{hour} - $gmtime->{hour}, " hours difference to GMT";

# comparison functions
my $byAge = $personType->cmp("birth : -num, lastname, firstname");
my $byNameLength = $personType->cmp(lastname => {length($b) length($a)},
lastname => alpha,
firstname => alpha);
showPerson($_) foreach (sort $byAge @people);
showPerson($_) foreach (sort $byNameLength @people);

# special comparisons : dates
my $US_DateCmp = $myHashType->cmp("someDateField : m/d/y");
my $FR_InverseDateCmp = $myHashType->cmp("someDateField : -d.m.y");

Force Content-Type is an extension used to force the Content-Type of URLs.

Its useful to avoid the tag soup when you are developing a XHTML webpage and want Firefox to use its internal XML parser. If the webserver is not correctly configured, it will serve the page with a text/html Content-Type (a tag soup), instead of sending it as application/xhtml+xml, and therefore avoiding Firefox to treat the page as pure XML.

Force Content-Type allows you to define the Content-Type of some URLs (using Regular Expressions), overriding the webservers incorrect Content-Type.

Supported locales:
- Basque
- English
- Spanish

Data::Type is a Perl module with versatile data and value types.

SYNOPSIS

use Data::Type qw(:all);
use Error qw(:try);

try
{
verify $email , EMAIL;
verify $homepage , URI(http);
verify $cc , CREDITCARD( MASTERCARD, VISA );
verify $answer_a , YESNO;
verify $gender , GENDER;
verify one , ENUM( qw(one two three) );
verify [qw(two six)], SET( qw(one two three four five six) ) );
verify $server_ip4 , IP(v4);
verify $server_ip6 , IP(v6);

verify A35231AH1 , CINS;
verify 14565935 , ISSN;
verify DE , LANGCODE;
verify German , LANGNAME;

verify 012345678905, UPC();
verify 5276440065421319, CREDITCARD( MASTERCARD ) );

verify ATGCAAAT , BIO::DNA;
verify AUGGGAAAU , BIO::RNA;

verify 01001001110110101, BINARY;
verify 0F 0C 0A, HEX;

verify 0 , DEFINED;
verify 234 , NUM( 20 );
verify 1 , BOOL( true );
verify 100 , INT;
verify 1.1 , REAL;

my $foo = bless( 123, SomeThing );

verify $foo , REF;
verify $foo , REF( qw(SomeThing Else) );
verify [ bar ] , REF( ARRAY );

verify x 20 , VARCHAR( 20 );
verify 2001-01-01 , DATE( MYSQL );
verify 16 Nov 94 22:28:20 PST , DATE( DATEPARSE );
verify 9999-12-31 23:59:59, DATETIME;
verify 1970-01-01 00:00:00, TIMESTAMP;
verify -838:59:59 , TIME;
verify 2155 , YEAR;
verify 69 , YEAR(2);
verify 0 x 20 , TINYTEXT;
verify 0 x 20 , MEDIUMTEXT;
verify 0 x 20 , LONGTEXT;
verify 0 x 20 , TEXT;

verify 80 , PORT;
verify www.cpan.org, DOMAIN;
}
catch Type::Exception with
{
my $e = shift;

printf "Expected %s %s at %s line %sn",
$e->value,
$e->type->info,
$e->was_file,
$e->was_line;

foreach my $entry ( testplan( $e->type ) )
{
printf "texpecting it %s %s ", $entry->[1] ? is : is NOT, $entry->[0]->info();
}
};

# believe it or not, this really works

foreach ( EMAIL, WORD, CREDITCARD( MASTERCARD, VISA ), BIO::DNA, HEX )
{
print $_->info;
print $_->usage;
print $_->export; # does it have other names
print $_->param; # what are my choice i.e. [yes,no]
print $_->isa( IType::Business ); # is it a Business related type ?
print $_->VERSION; # first apperance in Data::Type release
}

# tied interface (alias typ)

try
{
typ ENUM( qw(DNA RNA) ), ( my $a, my $b );

print "a is typed" if istyp( $a );

$a = DNA; # $alias only accepts DNA or RNA
$a = RNA;
$a = xNA; # throws exception

untyp( $alias );
}
catch Type::Exception ::with
{
printf "Expected %s %s at %s line %sn",
$e->value,
$e->type->info,
$e->was_file,
$e->was_line;
};

dverify( $email, EMAIL ) or die $!;

my $g = Data::Type::Guard->new(

allow => [ Human, Others ], # blessed objects of that type

tests =>
{
email => EMAIL( 1 ), # mxcheck ON ! see Email::Valid
firstname => WORD,
social_id => [ NUM, VARCHAR( 10 ) ],
contacts => sub { my %args = @_; exists $args{lucy} },
}
);

$g->inspect( $h );

# compact version

overify { email => EMAIL( 1 ), firstname => WORD }, $object_a, $object_b;

print toc();

print catalog();

This module supports versatile data and value types. Out of the ordinary it supports parameterised types (like databases have i.e. VARCHAR(80) ). When you try to feed a typed variable against some odd data, this module explains what he would have expected.

ptkmixer is a Perl Tk Audio Mixer with an easy-to-use GUI. You will need to have Tk and Audio-Mixer perl modules to run the program.Look in the documentation section for information how to install perl modules. Tested on Peanut Linux .

Type make install for default install.

Audio::File::Type represents an audio filetype.

An instance of an object inherited from Audio::File::Type is returned by the constructor of Audio::File. This object currently provides access to the audio files information like its audio properties (bitrate, sample rate, number of channels, ...) and the data stored in the files tag, but also providing access to the raw audio data and other information should be easy to be implemented.

METHODS

new

Constructor. In fact you dont need to use it. Please use Audio::File which will call the appropriate constructor corresponding to the files type.

init

This method will be called by the constructor. Its empty by default and should be overwritten by inheriting subclasses to initialize themselfes.

name

Returns the name of the audio file.

is_readable

Checks whether the file is readable or not. At the moment its only used by the constructor, but it will be more usefull with later versions of Audio::File.

is_writeable

Checks whether the file is writeable or not. At the moment youll probably dont need to call this method, but itll be more usefull as soon as changing the audio file is implemented.

tag

Returns a reference to the files tag object. See the documentation of Audio::File::Tag to learn about what the tag object does.

audio_properties

Returns a reference to the files audio properties object. See the documentation of Audio::File::AudioProperties to get information about what the audio properties object does.

save

Saves the audio file. This is not yet implemented but it should remember me to do it at some time..

type

Returns the files type.

keix is a QT user interface for eix, which is usefull for searching gentoo packages.

Installation:

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes a while. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Type `make install to install the programs and any data files and documentation.

4. You can remove the program binaries and object files from the source code directory by typing `make clean.

muhttpd (mu HTTP deamon) is a simple but complete Web server written in portable ANSI C. It supports static pages, CGI scripts, and MIME type based handlers.
It drops privileges before accepting any connections, and can log received requests.
It has been tested on OpenBSD, GNU/Linux, NetBSD, FreeBSD, Mac OS X, and Cygwin. muhttpd runs successfully on 32-bits, 64-bit, little endian, and big endian systems.
muhttpd understands a few configuration directives, described below.
port n Listen for connections on port n
webdir path Use path as the directory containing the web pages
webroot path chroot(2) to path
type type ext+ Treat files whose names end in one of the strings in ext+ (a space separated list) as if they were of type type
handler type program Pass files of type type through program
include file Read file as a configuration file
index name+ Specify which file to send when a directory index is requested. The first matching name is used
user username Switch to username before starting to accept connections
group groupname Switch to groupname before starting to accept connections
logfile file Log incoming requestst to file
Example:
port 80
webdir /var/www
logfile /var/log/muhttpd/logfile
user www
group www
index index.html index.php
type text/html .html
type text/css .css
type text/plain .txt
type application/x-httpd-php .php
type image/png .png
type image/jpeg .jpg .jpeg
handler application/x-httpd-php /usr/lib/cgi-bin/php
Enhancements:
- Fixes logging of IP addresses on OpenBSD.
- Flushes the log file before calling exec(2) to make sure entries make it to the log file.
- Connects standard error to the log file so errors from scripts are logged.