Free data replacement software for linux

Data::TreeDumper is an improved replacement for Data::Dumper. Powerful filtering capability.

SYNOPSIS

use Data::TreeDumper ;

my $sub = sub {} ;

my $s =
{
A =>
{
a =>
{
}
, bbbbbb => $sub
, c123 => $sub
, d => $sub
}

, C =>
{
b =>
{
a =>
{
a =>
{
}

, b => sub
{
}
, c => 42
}

}
}
, ARRAY => [qw(elment_1 element_2 element_3)]
} ;


#-------------------------------------------------------------------
# package setup data
#-------------------------------------------------------------------

$Data::TreeDumper::Useascii = 0 ;
$Data::TreeDumper::Maxdepth = 2 ;

print DumpTree($s, title) ;
print DumpTree($s, title, MAX_DEPTH => 1) ;
print DumpTrees
(
[$s, "title", MAX_DEPTH => 1]
, [$s2, "other_title", DISPLAY_ADDRESS => 0]
, USE_ASCII => 1
, MAX_DEPTH => 5
) ;

Output:

title:
|- A [H1]
| |- a [H2]
| |- bbbbbb = CODE(0x8139fa0) [C3]
| |- c123 [C4 -> C3]
| `- d [R5]
| `- REF(0x8139fb8) [R5 -> C3]
|- ARRAY [A6]
| |- 0 [S7] = elment_1
| |- 1 [S8] = element_2
| `- 2 [S9] = element_3
`- C [H10]
`- b [H11]
`- a [H12]
|- a [H13]
|- b = CODE(0x81ab130) [C14]
`- c [S15] = 42

GNU DDD is a graphical front-end for command-line debuggers such as GDB, DBX, WDB, Ladebug, JDB, XDB, the Perl debugger, the bash debugger, or the Python debugger.

Besides "usual front-end features such as viewing source texts, DDD has become famous through its interactive graphical data display, where data structures are displayed as graphs.

Google Data Objective-C Client provides a framework and source code that make it easy to access data through Google Data APIs.
The Google data APIs provide a simple protocol for reading and writing data on the web. Many Google services provide a Google data API.
Each of the following Google services provides a Google data API:
- Base
- Blogger
- Calendar
- Spreadsheets
- Picasa Web Albums
- Notebook
Additional services with Google data APIs that are not yet supported by the Objective-C Client Library:
- Code Search
- Google Apps Provisioning

Common Data Format is a self-describing data abstraction for the storage and manipulation of multidimensional data in a platform- and discipline-independent fashion.
It consists of a scientific data management package (known as the "CDF Library") that allows programmers and application developers to manage and manipulate scalar, vector, and multi-dimensional data arrays.
Enhancements:
- Adds new sets of APIs to allow Standard Interface to interact with zVariables and other CDF-related information.
- Adds MingW and FreeBSD ports.
- Adds support for Intel C++ and Fortran for Linux.
- Adds the ability to create legacy CDF 2.7 files.
- Fixes a bug that prevented directories from having .cdf or .skt extensions.

Data::Generate allows you to create various types of synthetic data by parsing "regex-like" data creation rules.

This module generates data by parsing given text statements (data creation rules). These statements are flexible and powerful regex-like way to control the production of synthetic data. Think about a program that instead of selecting data which matches a regex filter expression, produces it. For example, from the rule [a-c], the generator would produce the array a,b,c. The module works as following:

Specify data creation rules.
my $generator= Data::Generate::parse(VC(24) [0-9][2-3]);
At this step first you define one kind of output datatype (for ex. VC(24)= "output is a string with max length 24") and then with the rest of the expression define what it should look like. If parsing is successful a Data Generator object is instantiated.

Get data
my $Data= $generator->get_unique_data(10);
To really get the data, users must call the get_unique_data method by indicating the desired number of output values. The generator returns the values contained in an array reference. Please remark that output format is fixed according to the data type.

Data::Encrypted is a Perl module to transparently store encrypted data via RSA.

SYNOPSIS

# functional interface:
use Data::Encrypted file => "./.$0-encrypted-data", qw(encrypted);

# note: login and password are not *really* the login and
# password values, only the desired prompt!
my $login = encrypted(login);
my $password = encrypted(password);

# script continues, connecting to some secure resource (database,
# website, etc).

__END__

# alternative, OO interface:
use Data::Encrypted;

my $enc = new Data::Encrypted file => "./.$0-encrypted-data";
my $login = $enc->encrypted(login);
my $password = $enc->encrypted(password);
$enc->finished(); # close and release lock on storage file

# script continues, connecting to some secure resource (database,
# website, etc).

__END__

[ then, back at the command line: ]

% myscript.pl
Data::Encrypted value for login not found, please enter: *****
Data::Encrypted value for password not found, please enter: ********
[ script merrily continues ... ]

% myscript.pl
[ script merrily continues, no prompting this time ... ]

Often when dealing with external resources (database engines, ftp, telnet, websites, etc), your Perl script must supply a password, or other sensitive data, to the other system. This requires you to either continually prompt the user for the data, or to store the information (in plaintext) within your script. Youd rather not have to remember the connection details to all your different resources, so youd like to store the data somewhere. And if you share your script with anyone (as any good open-source developer would), youd rather not have your password or other sensitive information floating around.

Data::Encrypted attempts to fill this small void with a simple, yet functional solution to this common predicament. It works by prompting you (via Term::ReadPassword) once for each required value, but only does so the first time you run your script; thereafter, the data is stored encrypted in a secondary file. Subsequent executions of your script use the encrypted data directly, if possible; otherwise it again prompts for the data. Currently, Data::Encrypted achieves encryption via an RSA public-key cryptosystem implemented by Crypt::RSA, using (by default) your own SSH1 public and private keys.

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.