Free 0.13 software for linux

sql++ is an easily configurable, feature-rich, portable command-line SQL tool. It can be used with many different databases and in place of other commandline tools such as MySQLs mysql-client, Microsoft SQL, PostgreSQLs psql, and Oracles sqlplus.

sql++ project has features such as multiple connections, multi-database interfacing, subselects for all databases, regardless of whether the database has native subselects or not, and much more.

Boson is an OpenGL real-time strategy game. Boson is designed to run on Unix (Linux) computers, and is built on top of the KDE, Qt and kdegames libraries.

NMaven provides Maven 2.x plugins to support building of .NET applications. Technically, NMaven is its own framework that provides the correct .NET compiler based on the environment (vendor/language/operating system).
NMaven framework allows the developer to easily add additional compiler support by implementing the NetCompiler interface and providing a compiler-plugins.xml file in the project directory. NMaven leverages Maven (and its plugin architecture) for the build lifecycle. So you can think of NMaven as a small, compiler-plugin-framework on top of the larger Maven build-framework.
Main features:
- Mono Support: Out of the box, supports C#, Nemerle, PHP
- Microsoft Support: C#
- Pluggable architecture for adding new compilers.
Enhancements:
- This release includes the ability to generate and embed resources, as well as a way to provide hints to the compiler matching framework (through a settings file).
- Minor bug fixes.

oRTP is a library implementing the Real-time Transport Protocol (RFC3550), written in C.
oRTP project is easy to use and provides a packet scheduler for sending and receiving packets on time, adaptive jitter compensation, and automatic sending of RTCP compound packets. It works with IPv6.
Main features:
- Written in C
- Implement the RFC3550 (RTP) with a easy to use API with high and low level access.
- Includes support for multiples profiles, AV profile (RFC1890) being the one by default.
- Includes a packet scheduler for synchronizing rtp recv and send. Scheduling is optionnal, rtp sessions can remain not scheduled.
- Implements blocking and non blocking IO for RTP sessions.
- Supports mutiplexing IO, so that hundreds of RTP sessions can be managed by a single thread.
- Supports part of RFC2833 for telephone events over RTP.
- The API is well documented using gtk-doc.
- Licensed under the Lesser Gnu Public License.
- RTCP messages sent periodically since 0.7.0 (compound packet including sender report or receiver report + SDES)
Enhancements:
- This version includes new API documentation built with Doxygen and integrates minor patches and optimizations.

cvsd is a wrapper program for cvs in pserver mode.
cvsd is run as a daemon and is controlled through a configuration file. It is relatively easy to configure and tools are provided for setting up a rootjail.
This server can be useful if you want to run a public cvs pserver. You should however be aware of the security limitations of running a cvs pserver. If you want any kind of authentication you should really consider using secure shell as a secure authentication mechanism and transport. Passwords used in cvs pserver are transmitted in plaintext and this wrapper wont change that.
This server adds a layer of security to cvs. cvs is a very powerful tool and is capable of running scripts and other things. By running cvs in a rootjail it is possible to limit the amount of "damage" cvs can do if it is exploited. It is generally a good idea to run cvsd without any write permissions to any directory on the system.
Enhancements:
- This release adds some further portability improvements for 64-bit systems to the cvsd-buildroot command.
- Socket and file close operations are now checked, and a Portuguese debconf translation was added.

Lucene is a Perl API to the C++ port of the Lucene search engine.

SYNOPSIS

Initialize/Empty Lucene index

my $analyzer = new Lucene::Analysis::Standard::StandardAnalyzer();
my $store = Lucene::Store::FSDirectory->getDirectory("/home/lucene", 1);

my $tmp_writer = new Lucene::Index::IndexWriter($store, $analyzer, 1);
$tmp_writer->close;
undef $tmp_writer;

Choose your Analyzer (string tokenizer)

# lowercases text and splits it at non-letter characters
my $analyzer = new Lucene::Analysis::SimpleAnalyzer();
# same as before and removes stop words
my $analyzer = new Lucene::Analysis::StopAnalyzer();
# same as before but you provide your own stop words
my $analyzer = new Lucene::Analysis::StopAnalyzer([qw/that this in or and/]);
# splits text at whitespace characters
my $analyzer = new Lucene::Analysis::WhitespaceAnalyzer();
# lowercases text, tokenized it based on a grammer that
# leaves named authorities intact (e-mails, company names,
# web hostnames, IP addresses, etc) and removed stop words
my $analyzer = new Lucene::Analysis::Standard::StandardAnalyzer();
# same as before but you provide your own stop words
my $analyzer = new Lucene::Analysis::Standard::StandardAnalyzer([qw/that this in or and/]);
# takes string as it is (only when using clucene-0.9.17 or above)
my $analyzer = new Lucene::Analysis::KeywordAnalyzer();

Create a custom Analyzer

package MyAnalyzer;

use base Lucene::Analysis::Analyzer;

# You MUST called SUPER::new if you implement new()
sub new {
my $class = shift;
my $self = $class->SUPER::new();
# ...
return $self;
}

sub tokenStream {
my ($self, $field, $reader) = @_;
my $ret = new Lucene::Analysis::StandardTokenizer($reader);
if ($field eq "MyKeywordField") {
return $ret;
}
$ret = new Lucene::Analysis::LowerCaseFilter($ret);
$ret = new Lucene::Analysis::StopFilter($ret, [qw/foo bar bax/]);
return $ret;
}
package main;
my $analyzer = new MyAnalyzer;

Choose your Store (storage engine)

# in-memory storage
my $store = new Lucene::Store::RAMDirectory();
# disk-based storage
my $store = Lucene::Store::FSDirectory->getDirectory("/home/lucene", 0);

Open and configure an IndexWriter

my $writer = new Lucene::Index::IndexWriter($store, $analyzer, 0);
# optional settings for power users
$writer->setMergeFactor(100);
$writer->setUseCompoundFile(0);
$writer->setMaxFieldLength(255);
$writer->setMinMergeDocs(10);
$writer->setMaxMergeDocs(100);

Create Documents and add Fields

my $doc = new Lucene::Document;
# field gets analyzed, indexed and stored
$doc->add(Lucene::Document::Field->Text("content", $content));
# field gets indexed and stored
$doc->add(Lucene::Document::Field->Keyword("isbn", $isbn));
# field gets just stored
$doc->add(Lucene::Document::Field->UnIndexed("sales_rank", $sales_rank));
# field gets analyzed and indexed
$doc->add(Lucene::Document::Field->UnStored("categories", $categories));