Free thrown software for linux

Stones Throw project is an Arkanoid clone.

It comes with accurate 2D physics.

Unzip this zip file into any folder and run stonesthrow.bat

Tree::Binary is a Object Oriented Binary Tree for Perl.

SYNOPSIS

use Tree::Binary;

# a tree representaion of the expression:
# ((2 + 2) * (4 + 5))
my $btree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);
# Or shown visually:
# +---(*)---+
# | |
# +-(+)-+ +-(+)-+
# | | | |
# (2) (2) (4) (5)

# get a InOrder visitor
my $visitor = Tree::Binary::Visitor::InOrderTraversal->new();
$btree->accept($visitor);

# print the expression in infix order
print $visitor->getAccumulation(); # prints "2 + 2 * 4 + 5"

# get a PreOrder visitor
my $visitor = Tree::Binary::Visitor::PreOrderTraversal->new();
$btree->accept($visitor);

# print the expression in prefix order
print $visitor->getAccumulation(); # prints "* + 2 2 + 4 5"

# get a PostOrder visitor
my $visitor = Tree::Binary::Visitor::PostOrderTraversal->new();
$btree->accept($visitor);

# print the expression in postfix order
print $visitor->getAccumulation(); # prints "2 2 + 4 5 + *"

# get a Breadth First visitor
my $visitor = Tree::Binary::Visitor::BreadthFirstTraversal->new();
$btree->accept($visitor);

# print the expression in breadth first order
print $visitor->getAccumulation(); # prints "* + + 2 2 4 5"

# be sure to clean up all circular references
$btree->DESTROY();

This module is a fully object oriented implementation of a binary tree. Binary trees are a specialized type of tree which has only two possible branches, a left branch and a right branch. While it is possible to use an n-ary tree, like Tree::Simple, to fill most of your binary tree needs, a true binary tree object is just easier to mantain and use.

Binary Tree objects are especially useful (to me anyway) when building parse trees of things like mathematical or boolean expressions. They can also be used in games for such things as descisions trees. Binary trees are a well studied data structure and there is a wealth of information on the web about them.

This module uses exceptions and a minimal Design By Contract style. All method arguments are required unless specified in the documentation, if a required argument is not defined an exception will usually be thrown. Many arguments are also required to be of a specific type, for instance the $tree argument to both the setLeft and setRight methods, must be a Tree::Binary object or an object derived from Tree::Binary, otherwise an exception is thrown. This may seems harsh to some, but this allows me to have the confidence that my code works as I intend, and for you to enjoy the same level of confidence when using this module. Note however that this module does not use any Exception or Error module, the exceptions are just strings thrown with die.

This object uses a number of methods copied from another module of mine, Tree::Simple. Users of that module will find many similar methods and behaviors. However, it did not make sense for Tree::Binary to be derived from Tree::Simple, as there are a number of methods in Tree::Simple that just wouldnt make sense in Tree::Binary. So, while I normally do not approve of cut-and-paste code reuse, it was what made the most sense in this case.

Iterator::IO is a Perl module with filesystem and stream iterators.

SYNOPSIS

use Iterator::IO;

# Return the names of files in a directory (except . and ..)
$iter = idir_listing ($path);

# Return all the files in a directory tree, one at a time.
# Like File::Find, in slow motion.
$iter = idir_walk ($path);

# Return the lines of a file, one at a time.
$iter = ifile ($filename, %options);

# Return the lines of a file, in reverse order
$iter = ifile_reverse ($filename, %options);

This module provides filesystem and stream iterator functions. See the Iterator module for more information about how to use iterators.

FUNCTIONS

idir_listing

$iter = idir_listing ($path);

Iterator that returns the names of the files in the $path directory. If $path is omitted, defaults to the current directory. Does not return the . and .. files (under unix).

Requires IO::Dir and Cwd.

Example:

To return only certain files, combine this with an igrep:

$iter = igrep {-s && -M < 1} idir "/some/path";

(Returns non-empty files modified less than a day ago). (igrep) is defined in the Iterator::Util module).

idir_walk

$iter = idir_walk ($path);

Returns the files in a directory tree, one by one. Its sort of like File::Find in slow motion.

Requires IO::Dir and Cwd.

ifile

$iter = ifile ($filename, %options);

Opens a file, generates an iterator to return the lines of the file.
%options is a reference to a hash of options. Currently, two options are supported:

chomp

chomp => boolean indicates whether lines should be chomped before being returned by the iterator. The default is true.

$/

$/ => value specifies what string to use as the record separator. If not specified, the current value of $/ is used.

"rs" or "input_record_separator" may be used as option names instead of "$/", if you find that to be more readable. See the English module.

Option names are case-insensitive.

ifile requires IO::File.
ifile_reverse

$iter = ifile_reverse ($filename, %options);

Exactly the same as "ifile", but reads the lines of the file backwards.
The input_record_separator option values undef (slurp whole file) and scalar references (fixed-length records) are not currently supported.

INTERFACE CHANGE

In version 0.01 of Iterator::IO, the "ifile" and ifile_reverse functions accepted their options in a different manner. This has now changed to operate via a hash reference of options. The old way will still work, but is deprecated and will be removed in a future release.

EXPORTS

This module exports all function names to the callers namespace by default.

DIAGNOSTICS

Iterator::IO uses Exception::Class objects for throwing exceptions. If youre not familiar with Exception::Class, dont worry; these exception objects work just like $@ does with die and croak, but they are easier to work with if you are trapping errors.

See the Iterator module documentation for more information on how to trap and handle these exception objects.

Parameter Errors

Class: Iterator::X::Parameter_Error

You called an Iterator::IO function with one or more bad parameters. Since this is almost certainly a coding error, there is probably not much use in handling this sort of exception.

As a string, this exception provides a human-readable message about what the problem was.

Exhausted Iterators

Class: Iterator::X::Exhausted

You called value on an iterator that is exhausted; that is, there are no more values in the sequence to return.

As a string, this exception is "Iterator is exhausted."

I/O Errors

Class: Iterator::X::IO_Error

This exception is thrown when any sort of I/O error occurs; this only happens with the filesystem iterators.

This exception has one method, os_error, which returns the original $! that was trapped by the Iterator object.

As a string, this exception provides some human-readable information along with $!.

Internal Errors

Class: Iterator::X::Internal_Error

Something happened that I thought couldnt possibly happen. I would appreciate it if you could send me an email message detailing the circumstances of the error.

Eterm is a vt102 terminal emulator intended as a replacement for xterm. It is designed with a Freedom of Choice philosophy, leaving as much power, flexibility, and freedom as possible in the hands of the user.
Eterm is designed to look good and work well, but takes a feature-rich approach rather than one of minimalism. Current features include color support, background images (all Imlib-supported formats), theme support, and pseudo-transparency.
Enhancements:
- This release contains primarily bugfixes, particularly for dead keys, but has a few new features thrown in as well, like support for a "beep command" to replace the PC speaker beep, EWMH/xcompmgr window opacity support, 256-color support, and NetWM startup ID support.

Test::Exception is a Perl module to test exception based code.

SYNOPSIS

use Test::More tests => 5;
use Test::Exception;

# or if you dont need Test::More

use Test::Exception tests => 5;

# then...

# Check that something died
dies_ok { $foo->method1 } expecting to die;

# Check that something did not die
lives_ok { $foo->method2 } expecting to live;

# Check that the stringified exception matches given regex
throws_ok { $foo->method3 } qr/division by zero/, zero caught okay;

# Check an exception of the given class (or subclass) is thrown
throws_ok { $foo->method4 } Error::Simple, simple error thrown;

# all Test::Exceptions subroutines are guaranteed to preserve the state
# of $@ so you can do things like this after throws_ok and dies_ok
like $@, what the stringified exception should look like;

# Check that a test runs without an exception
lives_and { is $foo->method, 42 } method is 42;

# or if you dont like prototyped functions

dies_ok( sub { $foo->method1 }, expecting to die );
lives_ok( sub { $foo->method2 }, expecting to live );
throws_ok( sub { $foo->method3 }, qr/division by zero/,
zero caught okay );
throws_ok( sub { $foo->method4 }, Error::Simple,
simple error thrown );
lives_and( sub { is $foo->method, 42 }, method is 42 );

TjMSNLib is an MSN Messenger client library written in Java and designed to be platform independent. It supports file transfers, smilies, and multiple user chat sessions.
TjMSN was started as due to a lack of decent MSN Messenger clients for Linux, so I decided that I would write a client that was platform independent, so that I would run on both my desktop and laptop.
TjMSN is free software and it is licensed under the terms of the GNU General Public License.
Enhancements:
- This release fixes a few major bugs.
- The first was a stream flush bug which caused switch board sessions (chat sessions) to time out before they even started.
- Errors thrown when trying to set the traffic class on a TCP socket are no longer ignored.
- This was causing the library to crash while connecting on Mac OS X.
- Finally, problems which occurred when a user added you to their contact list while offline or online were fixed.

brandgang is a http firewall tunneling for Java applets with restricted network.
You should install the software like this:
Extract the archive to a (home-)directory. For now there are no
installation scripts or further installation instructions.
tar -xzvf brandgang-0.1.xxx.tar.gz
WinZip users check: TAR file smart CR/LF Conversion.
You will need to create directories "var" and "lib" by hand, if your
archiver ignores empty directories. Check MANIFEST for anything
missing.
Main features:
- This transparently uses the browser configured proxy, simulating duplex communication, by multiple java.net.HttpURLConnections to a http tunnel server, that forwards the connection. Because no reference to the proxy is made, no security exceptions will be thrown for restricted applets.
-
- A combination of encryption (RSA/RC4) and message digests(MD5) is used in an effort to secure an insecure datapath. Though this comes with only a (small) telnet and SSH client, it is supposed to be easy to modify other networking applets to use tunnels.
-
- You can still use modified clients for direct connections over tcp sockets. You can also use secured connections to the tunnel server over a common tcp socket, and have the connection forwarded.
-
- The tunnel server can forward to multiple servers, handling multiple tunnels concurrently. The tunnel server can handle requests from http clients for files,
- so you dont need to run any (other) httpd to host the applets. The tunnel server can be used to enable access to a LAN. You can allow accepting and connecting hosts for the tunnel server (besides setting a Java security policy).
-
- Both server and clients are written in Java.

Java::JCR::Exception is a Perl wrapper for repository exceptions.

SYNOPSIS

eval {
my $node = $root->add_node(foo, nt:unstructured);
};

if ($@) {
print STDERR "Failed to add node foo: $@n";
}

This class is used to make the exceptions thrown from the Java code work more nicely in Perl. Primarily, this involves performing nicer stringification than is provided by Inline::Java.