Free multiple formats software for linux

Multiple Time Sheets is a simple tool to help you keep track of how many hours you work and for whom.
It differs from most time-tracking software because its designed to work like paper that magically totals up hours.
Main features:
- Uses text files, requiring no database.
- Supports only one user per app, for simpler code.
- Sends and tracks invoices, and payments thereof.
- Features a rudimentary to-do list that displays your list as an outline.
- Sends you a backup of your data automatically.
- Assume the user prefers free-form data entry in text files rather than typing into forms.
- Uses the htmlMimeMail.php class by Richard Heye (phpguru.org).
- CSV and OPML exports of some data.
- Automatic hyperlinking from MTS to your favorite web-based software.
Enhancements:
- This release added a feature that replaces text patterns with links so that strings like "Bug 10" can link to a bug tracking application.
- CSV export was added for the timesheet along with OPML export for the to-do list.

Multistat is designed to be a flexible log file parser for multiple game servers.

Designed with an extensible plugin interface, it is able to process statistics for any game and output them in any format simply by the use of custom modules.

Currently modules for Halflife, Counterstrike Source, Unreal Tournament 2004, Call of Duty 1, Unreal Tournament, and HTML output are included.

The MPFR library is a C library for multiple-precision floating-point computations with exact rounding (also called correct rounding). It is based on the GMP multiple-precision library.

The main goal of MPFR is to provide a library for multiple-precision floating-point computation which is both efficient and has a well-defined semantics. It copies the good ideas from the ANSI/IEEE-754 standard for double-precision floating-point arithmetic (53-bit mantissa).

MPFR is free. It is distributed under the GNU Lesser General Public License (GNU Lesser GPL). The library has been registered in France by the Agence de Protection des Programmes under the number IDDN FR 001 120020 00 R P 2000 000 10800, on 15 March 2000.

This license guarantees your freedom to share and change MPFR, to make sure MPFR is free for all its users. Unlike the ordinary General Public License, the Lesser GPL enables developers of non-free programs to use MPFR in their programs. If you have written a new function for MPFR or improved an existing one, please share your work!

Format on Save is a Eclipse plugin to automatically organizes imports and formats code when saving a Java editor.

This is the exact equivalent as doing Ctrl-Shift-O, Ctrl-Shift-F before saving. New features: - Sort Members and Correct Indentation - preference page to configure defaults

DateTime::Format::Builder is a Perl module to create datetime parser classes and objects.

SYNOPSIS

package DateTime::Format::Brief;
our $VERSION = 0.07;
use DateTime::Format::Builder
(
parsers => {
parse_datetime => [
{
regex => qr/^(d{4})(dd)(dd)(dd)(dd)(dd)$/,
params => [qw( year month day hour minute second )],
},
{
regex => qr/^(d{4})(dd)(dd)$/,
params => [qw( year month day )],
},
],
}
);

DateTime::Format::Builder creates DateTime parsers. Many string formats of dates and times are simple and just require a basic regular expression to extract the relevant information. Builder provides a simple way to do this without writing reams of structural code.

Builder provides a number of methods, most of which youll never need, or at least rarely need. Theyre provided more for exposing of the modules innards to any subclasses, or for when you need to do something slightly beyond what I expected.

DBIx::SQLCrosstab::Format is a Perl module with formats results created by DBIx::SQLCrosstab.

SYNOPSIS

use DBIx::SQLCrosstab::Format;
my $dbh=DBI->connect("dbi:driver:database"
"user","password", {RaiseError=>1})
or die "error in connection $DBI::errstrn";

my $params = {
dbh => $dbh,
op => [ [ SUM, salary] ],
from => person INNER JOIN departments USING (dept_id),
rows => [
{ col => country},
],
cols => [
{
id => dept,
value =>department,
from =>departments
},
{
id => gender, from => person
}
]
};
my $xtab = DBIx::SQLCrosstab::Format->new($params)
or die "error in creation ($DBIx::SQLCrosstab::errstr)n";

my $query = $xtab->get_query("#")
or die "error in query building $DBIx::SQLCrosstab::errstrn";

if ( $xtab->get_recs) {
# do something with records, or use a built-in function
# to produce a well formatted HTML table
#
print $xtab->as_html;

print $xtab->as_xml;
print $xtab->as_yaml;
print $xtab->as_csv(header);
$xtab->as_xls("xtab.xls");
use Data::Dumper;
print Data::Dumper->Dump ([ $xtab->as_perl_struct(hoh)],
[hoh]);
print Data::Dumper->Dump ([ $xtab->as_perl_struct(losh)],
[losh]);
print Data::Dumper->Dump ([ $xtab->as_perl_struct(loh)],
[loh]);
}
else {
die "error in execution $DBIx::SQLCrosstab::errstrn";
}

DBIx::SQLCrosstab::Format is a class descending from DBIx::SQLCrosstab. Being a child class, it inherits its parent methods and can be used in the same way.

In addition, it provides methods to produce formatted output.

libpackman (Package Management) library provides a single API for accessing multiple package formats and package databases.

Libpackmans module support allows for other developers to quickly provide support for new package formats and database formats.

Libpackman is in the alpha stage. It currently supports reading of RPM packages, partial reading of Debian packages, reading of the RPM database, and reading/writing of the GNUpdate database. Packages can be queried, but installation is, for the moment, disabled.

NOTE: This is a development release, and may harm your system if you use it to install packages. We take no responsibility for corrupted package databases or filesystems.

Installation:

$ ./configure --prefix=/usr

Then compile it:

$ make

And finally, install it:

$ make install

DateTime::Format::Builder::Tutorial is a quick class on using Builder.

CREATING A CLASS

As most people who are writing modules know, you start a package with a package declaration and some indication of module version:

package DateTime::Format::ICal;
our $VERSION = 0.04;

After that, you call Builder with some options. There are only a few (detailed later). Right now, were only interested in parsers.

use DateTime::Format::Builder
(
parsers => {
...
}
);

The parsers option takes a reference to a hash of method names and specifications:

parsers => {
parse_datetime => ... ,
parse_datetime_with_timezone => ... ,
...
}

Builder will create methods in your class, each method being a parser that follows the given specifications. It is strongly recommended that one method is called parse_datetime, be it a Builder created method or one of your own.

In addition to creating any of the parser methods it also creates a new() method that can instantiate (or clone) objects of this class. This behaviour can be modified with the constructor option, but we dont need to know that yet.

Each value corresponding to a method name in the parsers list is either a single specification, or a list of specifications. Well start with the simple case.

parse_briefdate => {
params => [ qw( year month day ) ],
regex => qr/^(dddd)(dd)(dd)$/,
},

This will result in a method named parse_briefdate which will take strings in the form 20040716 and return DateTime objects representing that date. A user of the class might write:

use DateTime::Format::ICal;
my $date = "19790716";
my $dt = DateTime::Format::ICal->parse_briefdate( $date );
print "My birth month is ", $dt->month_name, "n";

The regex is applied to the input string, and if it matches, then $1, $2, ... are mapped to the params given and handed to DateTime->new(). Essentially:

my $rv = DateTime->new( year => $1, month => $2, day => $3 );

There are more complicated things one can do within a single specification, but well cover those later.

Often, youll want a method to be able to take one string, and run it against multiple parser specifications. It would be very irritating if the user had to work out what format the datetime string was in and then which method was most appropriate.

So, Builder lets you specify multiple specifications:

parse_datetime => [
{
params => [ qw( year month day hour minute second ) ],
regex => qr/^(dddd)(dd)(dd)T(dd)(dd)(dd)$/,
},
{
params => [ qw( year month day hour minute ) ],
regex => qr/^(dddd)(dd)(dd)T(dd)(dd)$/,
},
{
params => [ qw( year month day hour ) ],
regex => qr/^(dddd)(dd)(dd)T(dd)$/,
},
{
params => [ qw( year month day ) ],
regex => qr/^(dddd)(dd)(dd)$/,
},
],

Its an arrayref of specifications. A parser will be created that will try each of these specifications sequentially, in the order you specified.