Free data ctable 1.03 software for linux

Data::CTable is a Perl module that helps you read, write, manipulate tabular data.

SYNOPSIS

## Read some data files in various tabular formats
use Data::CTable;
my $People = Data::CTable->new("people.merge.mac.txt");
my $Stats = Data::CTable->new("stats.tabs.unix.txt");

## Clean stray whitespace in fields
$People->clean_ws();
$Stats ->clean_ws();

## Retrieve columns
my $First = $People->col(FirstName);
my $Last = $People->col(LastName );

## Calculate a new column based on two others
my $Full = [map {"$First->[$_] $Last->[$_]"} @{$People->all()}];

## Add new column to the table
$People->col(FullName => $Full);

## Another way to calculate a new column
$People->col(Key);
$People->calc(sub {no strict vars; $Key = "$Last,$First";});

## "Left join" records matching Stats:PersonID to People:Key
$Stats->join($People, PersonID => Key);

## Find certain records
$Stats->select_all();
$Stats->select(Department => sub {/Sale/i }); ## Sales depts
$Stats->omit (Department => sub {/Resale/i}); ## not Resales
$Stats->select(UsageIndex => sub {$_ > 20.0}); ## high usage

## Sort the found records
$Stats->sortspec(DeptNum , {SortType => Integer});
$Stats->sortspec(UsageIndex, {SortType => Number });
$Stats->sort([qw(DeptNum UsageIndex Last First)]);

## Make copy of table with only found/sorted data, in order
my $Report = $Stats->snapshot();

## Write an output file
$Report->write(_FileName => "Rept.txt", _LineEnding => "mac");

## Print a final progress message.
$Stats->progress("Done!");

## Dozens more methods and parameters available...

OVERVIEW

Data::CTable is a comprehensive utility for reading, writing, manipulating, cleaning and otherwise transforming tabular data. The distribution includes several illustrative subclasses and utility scripts.

A Columnar Table represents a table as a hash of data columns, making it easy to do data cleanup, formatting, searching, calculations, joins, or other complex operations.

The objects hash keys are the field names and the hash values hold the data columns (as array references).

Tables also store a "selection" -- a list of selected / sorted record numbers, and a "field list" -- an ordered list of all or some fields to be operated on. Select() and sort() methods manipulate the selection list. Later, you can optionally rewrite the table in memory or on disk to reflect changes in the selection list or field list.
Data::CTable reads and writes any tabular text file format including Merge, CSV, Tab-delimited, and variants. It transparently detects, reads, and preserves Unix, Mac, and/or DOS line endings and tab or comma field delimiters -- regardless of the runtime platform.

In addition to reading data files, CTable is a good way to gather, store, and operate on tabular data in memory, and to export data to delimited text files to be read by other programs or interactive productivity applications.

To achieve extremely fast data loading, CTable caches data file contents using the Storable module. This can be helpful in CGI environments or when operating on very large data files. CTable can read an entire cached table of about 120 megabytes into memory in about 10 seconds on an average mid-range computer.

For simple data-driven applications needing to store and quickly retrieve simple tabular data sets, CTable provides a credible alternative to DBM files or SQL.
For data hygiene applications, CTable forms the foundation for writing utility scripts or compilers to transfer data from external sources, such as FileMaker, Excel, Access, personal organizers, etc. into compiled or validated formats -- or even as a gateway to loading data into SQL databases or other destinations. You can easily write short, repeatable scripts in Perl to do reporting, error checking, analysis, or validation that would be hard to duplicate in less-flexible application environments.

The data representation is simple and open so you can directly access the data in the object if you feel like it -- or you can use accessors to request "clean" structures containing only the data or copies of it. Or you can build your own columns in memory and then when youre ready, turn them into a table object using the very flexible new() method.

The highly factored interface and implementation allow fine-grained subclassing so you can easily create useful lightweight subclasses. Several subclasses are included with the distribution.

Most defaults and parameters can be customized by subclassing, overridden at the instance level (avoiding the need to subclass too often), and further overridden via optional named-parameter arguments to most major method calls.

Thin SFTP Applet is a full featured Secure File Transfer Program. Thin SFTP Applet can be use for secure file transfer and management and can be easily integrated into your website or web application.
You can use our SFTP applet to carry out recursive folder uploads and downloads, with entire directory trees being transfered in a single click.
Interrupted transfers can be resumed. Unlike the FTP protocol, with SFTP all data and commands are encrypted for maximum security.
In spite of being a web client, its appearence is no different from a traditional 2-Table File Transfer Program for desktops.
Because the client is an applet it does not need to refresh itself each time a file transfer or any other operation takes place. The result is that the user experience is no different from using a desktop client.
Enhancements:
- A minor bug related to connection pooling and reuse was fixed.

Data::ENAML is a Perl extension for ENAML data representation.

SYNOPSIS

use Data::ENAML qw (serialize deserialize);

print serialize(login => {nick => Schop,
email => ariel@atheist.org.il,
tagline => If I had no modem I would not lose Regina});

$struct = deserialize(bad-nick: {nick: "c00l dewd" text: "spaces not allowed"});

ENAML stands for ENAML is Not A Markup Language. (And as we all know, Gnu is Not UNIX, Pine Is Not Email, Wine Is Not Emulator, Lame Aint Mp3 Encoder and so on).

ENAML was defined by Robey Pointer for use in Say2, check http://www.lag.net/say2.

Learn HTML By Example is a sweet little JavaScript / HTML program that allows you to see the HTML you input into on side displayed as a web page on the other.
To install the program, just download it from Web Design Factory, and upload it to your web site.
Main features:
- Easy installation. Just upload to your web site and youre done!
- Immediate feedback on testing HTML and CSS code
- Several examples of commonly used HTML and CSS elements
- No page refreshing required
- Easy to expand by adding new examples

Data::Stag is a Perl module with structured tags datastructures.

SYNOPSIS

# PROCEDURAL USAGE
use Data::Stag qw(:all);
$doc = stag_parse($file);
@persons = stag_find($doc, "person");
foreach $p (@persons) {
printf "%s, %s phone: %sn",
stag_sget($p, "family_name"),
stag_sget($p, "given_name"),
stag_sget($p, "phone_no"),
;
}

# OBJECT-ORIENTED USAGE
use Data::Stag;
$doc = Data::Stag->parse($file);
@persons = $doc->find("person");
foreach $p (@person) {
printf "%s, %s phone:%sn",
$p->sget("family_name"),
$p->sget("given_name"),
$p->sget("phone_no"),
;
}

This module is for manipulating data as hierarchical tag/value pairs (Structured TAGs or Simple Tree AGgreggates).

Test::Singleton is a test for Singleton classes.

SYNOPSIS

use Test::More tests => 1;
use Test::Singleton;
is_singleton( "Some::Class", "new", "instance" );

** If you are unfamiliar with testing read Test::Tutorial first! **

This is asimple, basic module for checking whether a class is a Singleton. A Singleton describes an object class that can have only one instance in any system. An example of a Singleton might be a print spooler or system registry, or any kind of central dispatcher.

For a description and discussion of the Singleton class, see "Design Patterns", Gamma et al, Addison-Wesley, 1995, ISBN 0-201-63361-2.

Convert::Bencode are functions for converting to/from bencoded strings.

SYNOPSIS

use Convert::Bencode qw(bencode bdecode);

my $string = "d4:ainti12345e3:key5:value4:type4:teste";
my $hashref = bdecode($string);

foreach my $key (keys(%{$hashref})) {
print "Key: $key, Value: ${$hashref}{$key}n";
}

my $encoded_string = bencode($hashref);
print $encoded_string."n";

This module provides two functions, bencode and bdecode, which encode and decode bencoded strings respectivly.

rwdaddresses project consists of an address book using flat files and RubyWebDialogs.
In addition to text data, contact photos can be added and viewed. You can sync contact names to/from an FTP site. It has context sensitive help. Additional applets can be downloaded.
The GUI interface used is RubyWebDialogs, which runs through a Web browser. Therefore, it is completely cross-platform.
This is part of the Tinker framework using Ruby, so applets can be added and removed.
Enhancements:
- Export vCard
- view raw vCard
- updated for rwdtinker 1.61