Free many types software for linux

GeoTypes is a Python library that implements both the OpenGIS/PostGIS and standard PostgreSQL geometry types. GeoTypes integrates with the psycopg Python/PostgreSQL interface.
It provides implementations of all of the OpenGIS/PostGIS classes, except (x,y,m) and (x,y,z,m). It currently supports the EWKB, HEXEWKB, WKB, and WKT formats.
Enhancements:
- Point and Box constructor now accept several argument types
- SRID optional in WKTParser.parseGeometry
- minor typo corrections
- added joinBoxes()

Archetypes project is a framework for developing new content types in Plone.
The power of Archetypes is first in automatically generating forms, second in providing a library of stock field types, form widgets, and field validators, third in easily integrating custom fields, widgets, and validators, and fourth in automating transformations of rich content.
Enhancements:
- Major bugfixes

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.

XML::Schema::Type::Simple is a base class for simple XML Schema datatypes.

SYNOPSIS

package XML::Schema::Type::whatever;
use base qw( XML::Schema::Type::Simple );
use vars qw( @FACETS );

@FACETS = (
minLength => 10,
maxLength => 30,
otherFacet => {
value => $n,
fixed => 1,
annotation => "a comment",
},
);

package main;

my $type = XML::Schema::Type::whatever->new()
|| die XML::Schema::Type::whatever->error();

my $item = $type->instance(some instance value)
|| die $type->error();

# NOTE: some issues still to resolve on the precise
# nature and structure of instances (currently hash ref).
print $item->{ value };

The XML::Schema::Type::Simple module is a base class for objects that represent XML Schema simple types.

Variable::Strongly::Typed is a Perl module to let some variables be strongly typed.

SYNOPSIS

use Variable::Strongly::Typed;
my $int :TYPE(int); # must have an int value
my $float :TYPE(float); # must have a float value
my $string :TYPE(string); # must not be a reference
my $file :TYPE(IO::File); # must be an IO::File
my @array_of_ints :TYPE(int); # Each slot must contain
# an int
my %hash_of_floats :TYPE(float); # Each value must be a float

my $int_own_error :TYPE(int, &my_own_error_handler);
# Roll my own error handler

my @array_of_rgb :TYPE(&red_green_blue); # my enumerated type

# For subs!!
sub return_an_int :TYPE(int) {
# .. do some stuff ..
return $something;
}

# ... and later ...

$int = 23; # All is well
$int = howdy!; # This line will croak with a good error message

$float = 3.23; # All is well, nothing to see here
$float = new XML::Parser; # croak!

$array_of_ints[23] = 44; # Groovy
$array_of_ints[12] = yah; # croak!

$hash_of_floats{pi} = 3.14159; # no problem
$hash_of_floats{e} = new IO::File; # croak!

# Return 1 if this val is RED, BLUE, or GREEN
# 0 otherwise
sub red_green_blue {
local $_ = shift;

/A RED z/xms || /A BLUE z/xms || /A GREEN z/xms;
}

$array_of_my_very_own_types[23] = 99; # croak!
$array_of_my_very_own_types[2] = BLUE; # OK!

$int_own_error = lksdklwe; # The sub my_own_error_hanlder
# will be # called with the
# offending value

my $got_it = return_an_int(); # Will croak (or call your error
# function) # if this sub doesnt
# return an int

This modules allow you to strongly type your variables. Also known as the no fun module - it can greatly enhance you codes quality and robustness.

By enforcing types on some (or all) of your variables you will eliminate a large class of careless (& not so careless) errors.

This could also aid an editor or code-browsing tools to verify code correctness without having to execute the script.

Planetoids is a game similar to bejeweled. The player must swap jewels to create combinations, including power and hyper jewels.

It includes a top score board to keep track of high player scores. Planetoids game also includes a hint feature, various jewel types, custom board sizes, and more.

Battery OSD is a program that displays battery information and other types of system information on screen with the OSD library.

Class::Meta::Type is a Perl module for data type validation and accessor building.

SYNOPSIS

package MyApp::TypeDef;

use strict;
use Class::Meta::Type;
use IO::Socket;

my $type = Class::Meta::Type->add( key => io_socket,
desc => IO::Socket object,
name => IO::Socket Object );

This class stores the various data types used by Class::Meta. It manages all aspects of data type validation and method creation. New data types can be added to Class::Meta::Type by means of the add() constructor. This is useful for creating custom types for your Class::Meta-built classes.

Note:This class manages the most advanced features of Class::Meta. Before deciding to create your own accessor closures as described in add(), you should have a thorough working knowledge of how Class::Meta works, and have studied the add() method carefully. Simple data type definitions such as that shown in the SYNOPSIS, on the other hand, are encouraged.