Free yazmin sullivan software for linux

Date::Manip is a date manipulation routines.

SYNOPSIS

use Date::Manip;

$version = DateManipVersion;

$date = ParseDate(@args);
$date = ParseDate($string);
$date = ParseDate($string);

@date = UnixDate($date,@format);
$date = UnixDate($date,@format);

$delta = ParseDateDelta(@args);
$delta = ParseDateDelta($string);
$delta = ParseDateDelta($string);

@str = Delta_Format($delta,$dec,@format);
$str = Delta_Format($delta,$dec,@format);

$recur = ParseRecur($string,$base,$date0,$date1,$flags);
@dates = ParseRecur($string,$base,$date0,$date1,$flags);

$flag = Date_Cmp($date1,$date2);

$d = DateCalc($d1,$d2 [,$errref] [,$del]);

$date = Date_SetTime($date,$hr,$min,$sec);
$date = Date_SetTime($date,$time);

$date = Date_SetDateField($date,$field,$val [,$nocheck]);

$date = Date_GetPrev($date,$dow,$today,$hr,$min,$sec);
$date = Date_GetPrev($date,$dow,$today,$time);

$date = Date_GetNext($date,$dow,$today,$hr,$min,$sec);
$date = Date_GetNext($date,$dow,$today,$time);

$name = Date_IsHoliday($date);

$listref = Events_List($date);
$listref = Events_List($date0,$date1);

$date = Date_ConvTZ($date);
$date = Date_ConvTZ($date,$from);
$date = Date_ConvTZ($date,"",$to);
$date = Date_ConvTZ($date,$from,$to);

$flag = Date_IsWorkDay($date [,$flag]);

$date = Date_NextWorkDay($date,$off [,$time]);

$date = Date_PrevWorkDay($date,$off [,$time]);

$date = Date_NearestWorkDay($date [,$tomorrowfirst]);

&Date_Init();
&Date_Init("VAR=VAL","VAR=VAL",...);
@list = Date_Init();
@list = Date_Init("VAR=VAL","VAR=VAL",...);

The above routines all check to make sure that Date_Init is called. If it hasnt been, they will call it automatically. As a result, there is usually no need to call Date_Init explicitely unless you want to change some of the config variables (described below). They also do error checking on the input.

The routines listed below are intended primarily for internal use by other Date::Manip routines. They do little or no error checking, and do not explicitely call Date_Init. Those functions are all done in the main Date::Manip routines above.

Because they are significantly faster than the full Date::Manip routines, they are available for use with a few caveats. Since little or no error checking is done, it is the responsibility of the programmer to ensure that valid data (AND valid dates) are passed to them. Passing invalid data (such as a non-numeric month) or invalid dates (Feb 31) will fail in unpredictable ways (possibly returning erroneous results). Also, since Date_Init is not called by these, it must be called explicitely by the programmer before using these routines.

In the following routines, $y may be entered as either a 2 or 4 digit year (it will be converted to a 4 digit year based on the variable YYtoYYYY described below). Month and day should be numeric in all cases. Most (if not all) of the information below can be gotten from UnixDate which is really the way I intended it to be gotten, but there are reasons to use these (these are significantly faster).

$day = Date_DayOfWeek($m,$d,$y);
$secs = Date_SecsSince1970($m,$d,$y,$h,$mn,$s);
$secs = Date_SecsSince1970GMT($m,$d,$y,$h,$mn,$s);
$days = Date_DaysSince1BC($m,$d,$y);
$day = Date_DayOfYear($m,$d,$y);
($y,$m,$d,$h,$mn,$s) = Date_NthDayOfYear($y,$n);
$days = Date_DaysInYear($y);
$days = Date_DaysInMonth($m,$y);
$wkno = Date_WeekOfYear($m,$d,$y,$first);
$flag = Date_LeapYear($y);
$day = Date_DaySuffix($d);
$tz = Date_TimeZone();

SMTPHandler is a handler for the java.util.logging library. SMTPHandler sends LogRecords via email using the Simple Mail Transfer Protocol.
The SMTPHandler code is derived from log4js SMTPAppender.
After downloading the SMTPHandler software, you will need to download two additional JAR files:
1) Sun JavaMail
http://java.sun.com/products/javamail
2) Sun JavaBeans Activiation Framework
http://java.sun.com/products/javabeans/glasgow/jaf.html
Enhancements:
- This release adds SMTP server authentication.
- You can specify an SMTP username and SMTP password.

Linux Napster Client is a console napster client written by Kevin Sullivan. It runs on Linux, OpenBSD, and other systems. Current releases of nap, such as 1.5.4, are very stable. They can run for weeks at a time without crashing or user intervention.
Nap, writtin by Kevin Sullivan sometime in 1999, was one of the first napster clients besides Shawn Fannings original Windows client. It was also the first client that ran on linux. Kevin learned much about the inner workings of the napster protocol by collaborating with Jordan Ritter, who was one of the co-founders of Napster and its Chief Server Architect at the time.
I took over the development of nap in February 2001. First I posted patches, but soon the patches became so long that I started making releases. A lot of features were added, and some existing ones redesigned, to make nap more stable, user-friendly, and reliable. However, the original "look and feel" has been preserved. Probably nap is one of the most robust napster clients for linux today. It has been packaged for a variety of popular platforms, and it is now shipped with some distributions of Debian Linux and OpenBSD.
Enhancements:
- This release changes the default meta-server to www.gotnap.com.

Class::Simple is a simple Object-Oriented Base Class.

SYNOPSIS

package Foo:
use base qw(Class::Simple);

BEGIN
{
Foo->privatize(qw(attrib1 attrib2)); # ...or not.
}
my $obj = Foo->new();

$obj->attrib(1); # The same as...
$obj->set_attrib(1); # ...this.

my $var = $obj->get_attrib(); # The same as...
$var = $obj->attrib; # ...this.

$obj->raise_attrib(); # The same as...
$obj->set_attrib(1); # ...this.

$obj->clear_attrib(); # The same as...
$obj->set_attrib(undef); # ...this
$obj->attrib(undef); # ...and this.

$obj->readonly_attrib(4);

sub foo
{
my $self = shift;
my $value = shift;

$self->_foo($value);
do_other_things(@_);
...
}

my $str = $obj->DUMP;
my $new_obj = Foo->new();
$new_obj->SLURP($str);

sub BUILD
{
my $self = shift;

# Various initializations
}

There are plenty of others that are much more thorough and whatnot but sometimes I want something simple so I can get just going (no doubt because I am a simple guy) so I use this.

What do I mean by simple? First off, I dont want to have to list out all my methods beforehand. I just want to use them (Yeah, yeah, it doesnt catch typos--thats what testing and Class::Std are for :-). Next, I want to be able to call my methods by $obj->foo(1) or $obj->set_foo(1), by $obj->foo() or $obj->get_foo(). Dont tell ME I have to use get_ and set_ (I would just override that restriction in Class::Std anyway). Simple!

I did want some neat features, though, so these are inside-out objects (meaning the object isnt simply a hash so you cant just go in and muck with attributes outside of methods), privatization of methods is supported, as is serialization out and back in again.