Free data entry jobs software for linux

Data::ICal::Entry::Todo is a Perl module that represents a to-do entry in an iCalendar file.

SYNOPSIS

my $vtodo = Data::ICal::Entry::Todo->new();
$vtodo->add_properties(
summary => "go to sleep",
status => INCOMPLETE,
# Dat*e*::ICal is not a typo here
dtstart => Date::ICal->new( epoch => time )->ical,
);

$calendar->add_entry($vtodo);

$vtodo->add_entry($alarm);

A Data::ICal::Entry::Todo object represents a single to-do entry in an iCalendar file. (Note that the iCalendar RFC refers to entries as "components".) It is a subclass of Data::ICal::Entry and accepts all of its methods.

Data::ICal::Entry::Event is a Perl module that represents an event in an iCalendar file.

SYNOPSIS

my $vevent = Data::ICal::Entry::Event->new();
$vevent->add_properties(
summary => "my party",
description => "Ill cry if I want to",
# Dat*e*::ICal is not a typo here
dtstart => Date::ICal->new( epoch => time )->ical,
);

$calendar->add_entry($vevent);

$vevent->add_entry($alarm);

A Data::ICal::Entry::Event object represents a single event in an iCalendar file. (Note that the iCalendar RFC refers to entries as "components".) It is a subclass of Data::ICal::Entry and accepts all of its methods.

Data::ICal::Entry::TimeZone is a Perl module to represents a time zone definition in an iCalendar file.

SYNOPSIS

my $vtimezone = Data::ICal::Entry::TimeZone->new();
$vtimezone->add_properties(
tzid => "US-Eastern",
tzurl => "http://zones.stds_r_us.net/tz/US-Eastern"
);

$vtimezone->add_entry($daylight); # daylight/ standard not yet implemented
$vtimezone->add_entry($standard); # :-(

$calendar->add_entry($vtimezone);

A Data::ICal::Entry::TimeZone object represents the declaration of a time zone in an iCalendar file. (Note that the iCalendar RFC refers to entries as "components".) It is a subclass of Data::ICal::Entry and accepts all of its methods.

This module is not yet useful, because every time zone declaration needs to contain at least one STANDARD or DAYLIGHT component, and these have not yet been implemented.

Data::Type is a Perl module with versatile data and value types.

SYNOPSIS

use Data::Type qw(:all);
use Error qw(:try);

try
{
verify $email , EMAIL;
verify $homepage , URI(http);
verify $cc , CREDITCARD( MASTERCARD, VISA );
verify $answer_a , YESNO;
verify $gender , GENDER;
verify one , ENUM( qw(one two three) );
verify [qw(two six)], SET( qw(one two three four five six) ) );
verify $server_ip4 , IP(v4);
verify $server_ip6 , IP(v6);

verify A35231AH1 , CINS;
verify 14565935 , ISSN;
verify DE , LANGCODE;
verify German , LANGNAME;

verify 012345678905, UPC();
verify 5276440065421319, CREDITCARD( MASTERCARD ) );

verify ATGCAAAT , BIO::DNA;
verify AUGGGAAAU , BIO::RNA;

verify 01001001110110101, BINARY;
verify 0F 0C 0A, HEX;

verify 0 , DEFINED;
verify 234 , NUM( 20 );
verify 1 , BOOL( true );
verify 100 , INT;
verify 1.1 , REAL;

my $foo = bless( 123, SomeThing );

verify $foo , REF;
verify $foo , REF( qw(SomeThing Else) );
verify [ bar ] , REF( ARRAY );

verify x 20 , VARCHAR( 20 );
verify 2001-01-01 , DATE( MYSQL );
verify 16 Nov 94 22:28:20 PST , DATE( DATEPARSE );
verify 9999-12-31 23:59:59, DATETIME;
verify 1970-01-01 00:00:00, TIMESTAMP;
verify -838:59:59 , TIME;
verify 2155 , YEAR;
verify 69 , YEAR(2);
verify 0 x 20 , TINYTEXT;
verify 0 x 20 , MEDIUMTEXT;
verify 0 x 20 , LONGTEXT;
verify 0 x 20 , TEXT;

verify 80 , PORT;
verify www.cpan.org, DOMAIN;
}
catch Type::Exception with
{
my $e = shift;

printf "Expected %s %s at %s line %sn",
$e->value,
$e->type->info,
$e->was_file,
$e->was_line;

foreach my $entry ( testplan( $e->type ) )
{
printf "texpecting it %s %s ", $entry->[1] ? is : is NOT, $entry->[0]->info();
}
};

# believe it or not, this really works

foreach ( EMAIL, WORD, CREDITCARD( MASTERCARD, VISA ), BIO::DNA, HEX )
{
print $_->info;
print $_->usage;
print $_->export; # does it have other names
print $_->param; # what are my choice i.e. [yes,no]
print $_->isa( IType::Business ); # is it a Business related type ?
print $_->VERSION; # first apperance in Data::Type release
}

# tied interface (alias typ)

try
{
typ ENUM( qw(DNA RNA) ), ( my $a, my $b );

print "a is typed" if istyp( $a );

$a = DNA; # $alias only accepts DNA or RNA
$a = RNA;
$a = xNA; # throws exception

untyp( $alias );
}
catch Type::Exception ::with
{
printf "Expected %s %s at %s line %sn",
$e->value,
$e->type->info,
$e->was_file,
$e->was_line;
};

dverify( $email, EMAIL ) or die $!;

my $g = Data::Type::Guard->new(

allow => [ Human, Others ], # blessed objects of that type

tests =>
{
email => EMAIL( 1 ), # mxcheck ON ! see Email::Valid
firstname => WORD,
social_id => [ NUM, VARCHAR( 10 ) ],
contacts => sub { my %args = @_; exists $args{lucy} },
}
);

$g->inspect( $h );

# compact version

overify { email => EMAIL( 1 ), firstname => WORD }, $object_a, $object_b;

print toc();

print catalog();

This module supports versatile data and value types. Out of the ordinary it supports parameterised types (like databases have i.e. VARCHAR(80) ). When you try to feed a typed variable against some odd data, this module explains what he would have expected.

Local Data Manager (LDM) is a collection of cooperating programs that select, capture, manage, and distribute arbitrary data products.
The system is designed for event-driven data distribution, and is currently used in the Unidata Internet Data Distribution (IDD) project. The LDM system includes network client and server programs and their shared protocols.
An important characteristic of the LDM is its support for flexible, site-specific configuration.
Enhancements:
- Fixes for timestamp bugs.

Data::Page is a Perl module that helps when paging through sets of results.

SYNOPSIS

use Data::Page;

my $page = Data::Page->new();
$page->total_entries($total_entries);
$page->entries_per_page($entries_per_page);
$page->current_page($current_page);

print " First page: ", $page->first_page, "n";
print " Last page: ", $page->last_page, "n";
print "First entry on page: ", $page->first, "n";
print " Last entry on page: ", $page->last, "n";

When searching through large amounts of data, it is often the case that a result set is returned that is larger than we want to display on one page. This results in wanting to page through various pages of data. The maths behind this is unfortunately fiddly, hence this module.

The main concept is that you pass in the number of total entries, the number of entries per page, and the current page number. You can then call methods to find out how many pages of information there are, and what number the first and last entries on the current page really are.

For example, say we wished to page through the integers from 1 to 100 with 20 entries per page. The first page would consist of 1-20, the second page from 21-40, the third page from 41-60, the fourth page from 61-80 and the fifth page from 81-100. This module would help you work this out.

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