data

Data is a utility that can allow you to manage your Pocket PC databases. Its a version adapted for Windows CE 2.11 that nonetheless runs under Pocket PC.

Here are some key features of "Data":

· Create User Database& Delete Database.
· Edit, Amendment, and delete data record.
· Change, add and delete field labels, and type
· Field type support Image, and sound
· Search record by given text.
· Import & Export to CSV File format - include Import and export Chinese, Japanese Text files, will will support convert Unicode from/to localized internal code (Big5/GB/SJIS).

HDR-Data Recovery Software has become the clear choice of professional data recovery techs worldwide. HDR-Data Recovery software is a low-cost, get-it-yourself data recovery solution capable of capturing lost or inaccessible data from your drive drive and re-constructing the file system (including from drives larger than 8.4gb!). Unlike some recovery utilities, which put your data at risk by attempting to repair corruption, HDR-Data Recovery never writes to the original drive. Instead, it rebuilds the file table in memory to facilitate the safe transfer of data to another device. Try HDR-Data at no risk. * While HDR-Data is a very powerful tool, there are cases where the expertise of an engineer is required. For those cases, Softech provides other solutions, including our lab services. Product Requirements/Features HDR-Data requirements: 486DX4-100 Mhz or greater processor 8 MB of RAM DOS, Windows 3.x, 95/98, NT The HDR-Data advantage: Safe, same day solution Economic

Data::ICal is a Perl module that generates iCalendar (RFC 2445) calendar files.

SYNOPSIS

use Data::ICal;

my $calendar = Data::ICal->new();

my $vtodo = Data::ICal::Entry::Todo->new();
$vtodo->add_properties(
# ... see Data::ICal::Entry::Todo documentation
);

# ... or

$calendar = Data::ICal->new(filename => foo.ics); # parse existing file
$calendar = Data::ICal->new(data => BEGIN:VCALENDAR...); # parse existing file


$calendar->add_entry($vtodo);

print $calendar->as_string;

# Or, if youre printing to something you want google to read:
print $calendar->as_string(fold => 0);

A Data::ICal object represents a VCALENDAR object as defined in the iCalendar protocol (RFC 2445, MIME type "text/calendar"), as implemented in many popular calendaring programs such as Apples iCal.

Each Data::ICal object is a collection of "entries", which are objects of a subclass of Data::ICal::Entry. The types of entries defined by iCalendar (which refers to them as "components") include events, to-do items, journal entries, free/busy time indicators, and time zone descriptors; in addition, events and to-do items can contain alarm entries. (Currently, Data::ICal only implements to-do items and events.)
Data::ICal is a subclass of Data::ICal::Entry; see its manpage for more methods applicable to Data::ICal.

Data Loader is a simple yet powerful tool to import and export Data between many common formats. Current Data Loader Ver. 2.0 supports MySQL, Oracle, MS Access, FoxPro, DBFs and Delimited or Flat Files. You can use Data Loader to transfer data from one database format to another database format. While transferring you can filter columns and specify WHERE conditions.
It supports Long , Picture Data types. In a jiffy you can copy data without any coding.
Supported O/s: Win 2003, Win 2000, XP, Win ME,Win98 &Win95

Now you can also Save and Schedule Sessions and Data Loader Scheduler will automatically executes sessions at your specified date and time.

Repository is introduced in Ver. 2.0. Now you can manage all your Sessions very easily.

Data Scripter is a useful addin that allows you to create T-SQL scripts which contains INSERT statements with data from given table in just a few clicks.

Data::SimplePassword provides a simple random password generator.

SYNOPSIS

use Data::SimplePassword;

my $sp = Data::SimplePassword->new;
$sp->chars( 0..9, a..z, A..Z ); # optional

my $password = $sp->make_password( 8 ); # length

Its a very easy-to-use but a bit strong random password generator.

Data.FormValidators aim is to bring all the benefits of the perl module Data::FormValidator over to javascript, using the same input profiles (they can be dumped into javascript objects using the perl module Data::JavaScript.

Data.FormValidator library lets you define profiles which declare the required and optional fields and any constraints they might have.

The results are provided as an object which makes it easy to handle missing and invalid results, return error messages about which constraints failed, or process the resulting valid data.

IMPORTANT NOTE: JavaScript form validation is NOT a replacement for data validation in your backend scripts. This is the primary reason this module was written... so that it would be easy to share the same validation profile for both the frontend (via Data.FormValidator.js) and backend (via Data::FormValidator.pm).

Whats New in This Release:

· A problem where some functions were not terminated by a semi-colon, so JavaScript compactors would end up creating broken code was fixed.

Data Nuker simply destroys files, free space and your Recycle Bin contents instead of only deleting them.

Data Nuker Shredding a disks free space ensures that any deleted data stored in unallocated clusters will be completely shredded and all the bits and pieces of left over data from deleted files will be destroyed.

NOTE:That means your data contents one overwritten and destroyed and cant be recovered.

Here are some key features of "Data Nuker":

· Shred Scheduler.
· Shred files, folders and the recycle bin.
· Shred drives.
· Shred free space.

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

Data Questor is one of the fastest known website downloaders and data extractor available today. Data Questor gives you complete control over including and excluding downloads from individual servers, folders, URLs, and files using keywords.

Data Questor is essentially a data search robot and is designed for fast-track navigation through the hyperlinks of cyber space, extracting data and downloading web pages at the users request. It offers numerous settings and options to facilitate this task. You can also limit your search by domain types (such as com, net, uk, etc.) by using sophisticated filtering options based on a list of key words and other auxiliary options. Data Questor can extract data from many websites simultaneously.

The result of this search will appear on the toolbar and you can save it in the registered version of the program. The unregistered version of the program will not allow you to download more than 50 records and does not allow you to save search results. Aside from addresses the file can save the URL of pages where you found your data.

Data::Str2Num - int str to int; float str to float, else undef.

SYNOPSIS

#####
# Subroutine interface
#
use Data::Str2Num qw(config str2float str2int str2integer);

$float = str2float($string, [@options]);
(@strings, @floats) = str2float(@strings, [@options]);

$integer = $secspack->str2int($string);

$integer = str2integer($string, [@options]);
(@strings, @integers) = str2int(@strings, [@options]);


#####
# Class, Object interface
#
# For class interface, use Data::SecsPack instead of $self
#
use Data::Str2Num;

$str2num = Data::Str2Num;
$str2num = new Data::Str2Num;

$float = $secspack->str2float($string, [@options]);
(@strings, @floats) = $secspack->str2float(@strings, [@options]);

$integer = $secspack->str2int($string);

$integer = $secspack->str2integer($string, [@options])
(@strings, @integers) = $secspack->str2int(@strings, [@options]);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

Data::PropertyList is a Perl module that can convert arbitrary objects to/from strings.

SYNOPSIS

use Data::PropertyList qw(astext fromtext);

$hash_ref = { items => [ 7 .. 11 ], key => value };
$string = astext($hash_ref);
# ...
$hash_ref = fromtext($string);
print $hash_ref->{items}[0];

$array_ref = [ 1, { key => value }, Omega ];
$string = astext($array_ref);
# ...
$array_ref = fromtext($string, -array=>1 );
print $array_ref->[1]{key};

Data::Propertylist provides functions that turn data structures with nested references into NeXTs Property List text format and back again.

You may find this useful for saving and loading application information in text files, or perhaps for generating error messages while debugging.

astext( $reference ) : $propertylist_string;

Writes out a nested Perl data structure in NeXT property list format.

fromtext( $propertylist_string ) : $hash_ref

fromtext( $propertylist_string, -array=>1 ) : $array_ref

Reconstructs a Perl data structure of nested references and scalars from a NeXT property list. Use the -array flag if the string encodes an array rather than a hash.

Data::Serializer package contains modules that serialize data structures.

SYNOPSIS

use Data::Serializer;

$obj = Data::Serializer->new();

$obj = Data::Serializer->new(
serializer => Storable,
digester => MD5,
cipher => DES,
secret => my secret,
compress => 1,
);

$serialized = $obj->serialize({a => [1,2,3],b => 5});
$deserialized = $obj->deserialize($serialized);
print "$deserialized->{b}n";

Provides a unified interface to the various serializing modules currently available. Adds the functionality of both compression and encryption.

EXAMPLES

Please see Data::Serializer::Cookbook(3)

METHODS

new - constructor
$obj = Data::Serializer->new();


$obj = Data::Serializer->new(
serializer => Data::Dumper,
digester => SHA-256,
cipher => Blowfish,
secret => undef,
portable => 1,
compress => 0,
serializer_token => 1,
options => {},
);

new is the constructor object for Data::Serializer objects.

The default serializer is Data::Dumper
The default digester is SHA-256
The default cipher is Blowfish
The default secret is undef
The default portable is 1
The default encoding is hex
The default compress is 0
The default compressor is Compress::Zlib
The default serializer_token is 1
The default options is {} (pass nothing on to serializer)
serialize - serialize reference

$serialized = $obj->serialize({a => [1,2,3],b => 5});

Serializes the reference specified.
Will compress if compress is a true value.
Will encrypt if secret is defined.
deserialize - deserialize reference

$deserialized = $obj->deserialize($serialized);

Reverses the process of serialization and returns a copy of the original serialized reference.

freeze - synonym for serialize
$serialized = $obj->freeze({a => [1,2,3],b => 5});

thaw - synonym for deserialize
$deserialized = $obj->thaw($serialized);

raw_serialize - serialize reference in raw form
$serialized = $obj->raw_serialize({a => [1,2,3],b => 5});

This is a straight pass through to the underlying serializer, nothing else is done. (no encoding, encryption, compression, etc)

raw_deserialize - deserialize reference in raw form
$deserialized = $obj->raw_deserialize($serialized);

This is a straight pass through to the underlying serializer, nothing else is done. (no encoding, encryption, compression, etc)

secret - specify secret for use with encryption
$obj->secret(mysecret);

Changes setting of secret for the Data::Serializer object. Can also be set in the constructor. If specified than the object will utilize encryption.

portable - encodes/decodes serialized data

Uses encoding method to ascii armor serialized data

Aids in the portability of serialized data.

compress - compression of data

Compresses serialized data. Default is not to use it. Will compress if set to a true value $obj->compress(1);

serializer - change the serializer

Currently have 8 supported serializers: Storable, FreezeThaw, Data::Denter, Config::General, YAML, PHP::Serialization, XML::Dumper, and Data::Dumper.
Default is to use Data::Dumper.

Each serializer has its own caveats about usage especially when dealing with cyclical data structures or CODE references. Please see the appropriate documentation in those modules for further information.

cipher - change the cipher method

Utilizes Crypt::CBC and can support any cipher method that it supports.

digester - change digesting method

Uses Digest so can support any digesting method that it supports. Digesting function is used internally by the encryption routine as part of data verification.

compressor - changes compresing module

This method is included for possible future inclusion of alternate compression method Currently Compress::Zlib is the only supported compressor.

encoding - change encoding method

Encodes data structure in ascii friendly manner. Currently the only valid options are hex, or b64.

The b64 option uses Base64 encoding provided by MIME::Base64, but strips out newlines.

serializer_token - add usage hint to data

Data::Serializer prepends a token that identifies what was used to process its data. This is used internally to allow runtime determination of how to extract Serialized data. Disabling this feature is not recommended.

options - pass options through to underlying serializer

Currently is only supported by Config::General, and XML::Dumper.

my $obj = Data::Serializer->new(serializer => Config::General,
options => {
-LowerCaseNames => 1,
-UseApacheInclude => 1,
-MergeDuplicateBlocks => 1,
-AutoTrue => 1,
-InterPolateVars => 1
},
) or die "$!n";

or

my $obj = Data::Serializer->new(serializer => XML::Dumper,
options => { dtd => 1, }
) or die "$!n";
store - serialize data and write it to a file (or file handle)
$obj->store({a => [1,2,3],b => 5},$file, [$mode, $perm]);

or

$obj->store({a => [1,2,3],b => 5},$fh);

Serializes the reference specified using the serialize method and writes it out to the specified file or filehandle.

If a file path is specified you may specify an optional mode and permission as the next two arguments. See IO::File for examples.

Trips an exception if it is unable to write to the specified file.

retrieve - read data from file (or file handle) and return it after deserialization

my $ref = $obj->retrieve($file);

or

my $ref = $obj->retrieve($fh);

Reads first line of supplied file or filehandle and returns it deserialized.

Data Paint description
Data Paint is a program that was designed to allow the user to paint the data in charts and graphs visually and numerically Data Paint is a free program that was designed to allow the user to paint the data in charts and graphs visually and numerically. For each chart or graph there is an icon, each icon can be placed in folder much like the Windows operating system.

Painting the data in one graph would automatically be applied to other charts and graphs sharing the same folder.

To identify each data on a graph place the cursor on the data point on a graph and press the right mouse button this will display the ID for that data.

Data can be loaded directly from Excel file or ASCII file. Currently the program can display bivariate scatter plot, bar chart, parallel coordinates plot, color histogram, three dimensional rotating scatter plot, single variable statistics information, and bivariate statistics information.

In bivariate scatter plot the user can have up to 20 regression lines for different colors. The software can be customized to accept other kind of charts and modification.

Data Paint is statistical software designed with ease of use and user friendly functionalities in mind.

The current version utilizes GUI (Graphical User Interface) language to link charts, graphs and statistical information about selected groups of data. For each graph and statistics windows, there is a corresponding handle.

Using these handles, the charts can interact with each other by way of painting the data.

The user can generate as many handles as desired and have them linked according to the information desired. The link between the handles can be changed at any time throughout the program.

The user can also partition data in a group of linked graphs and apply the coloring scheme to a different set of linked graphs.

Data Paint is designed to read data from an ASCII data file with tab or space as delimiters.

Requirements:

· Processor: 100 MHz
· RAM: 16 MByte
· Hard Drive Space: 6 Mbyte


Limitations:

· 30 minutes trial