Free bookable entry exit points gas software for linux

Last Exit is a player for the LastFM radio station.
It has most of the useful features that the official player has including
- Stream support
- Station searching
- Tagging
- Journalling
- Access to subscriber features
It also has more powerful searches for stations including Neighbours personal stations, users stations and fan stations.

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.

AtExit is a Perl module that can perform exit processing for a program or object.

SYNOPSIS

use AtExit;

sub cleanup {
my @args = @_;
print "cleanup() executing: args = @argsn";
}

## Register subroutines to be called when this program exits

$_ = atexit(&cleanup, "This call was registered first");
print "first call to atexit() returned $_n";

$_ = atexit("cleanup", "This call was registered second");
print "second call to atexit() returned $_n";

$_ = atexit("cleanup", "This call shouldve been unregistered by rmexit");
rmexit($_) or warn "couldnt unregister exit-sub $_!";

if (@ARGV == 0) {
## Register subroutines to be called when this lexical scope is exited
my $scope1 = AtExit->new( &cleanup, "Scope 1, Callback 1" );
{
## Do the same for this nested scope
my $scope2 = AtExit->new;
$_ = $scope2->atexit( &cleanup, "Scope 2, Callback 1" );
$scope1->atexit( &cleanup, "Scope 1, Callback 2");
$scope2->atexit( &cleanup, "Scope 2, Callback 2" );
$scope2->rmexit($_) or warn "couldnt unregister exit-sub $_!";

print "*** Leaving Scope 2 ***n";
}
print "*** Finished Scope 2 ***n";
print "*** Leaving Scope 1 ***n";
}
print "*** Finished Scope 1 ***n" if (@ARGV == 0);

END {
print "*** Now performing program-exit processing ***n";
}

The AtExit module provides ANSI-C style exit processing modeled after the atexit function in the standard C library (see atexit(3C)). Various exit processing routines may be registered by calling atexit and passing it the desired subroutine along with any desired arguments. Then, at program-exit time, the subroutines registered with atexit are invoked with their given arguments in the reverse order of registration (last one registered is invoked first). Registering the same subroutine more than once will cause that subroutine to be invoked once for each registration.

An AtExit object can be created in any scope. When invoked as a function, atexit registers callbacks to be executed at program-exit time. But when invoked as an object-method (using the $object->method_name syntax), callbacks registered with an AtExit object are executed at object-destruction time! The rules for order of execution of the registered subroutines are the same for objects during object-destruction, as for the program during program-termination.

The atexit function/method should be passed a subroutine name or reference, optionally followed by the list of arguments with which to invoke it at program/object exit time. Anonymous subroutine references passed to atexit act as "closures" (which are described in perlref). If a subroutine name is specified (as opposed to a subroutine reference) then, unless the subroutine name has an explicit package prefix, it is assumed to be the name of a subroutine in the callers current package. A reference to the specified subroutine is obtained, and, if invocation arguments were specified, it is "wrapped up" in a closure which invokes the subroutine with the specified arguments. The resulting subroutine reference is added to the front of the list of exit-handling subroutines for the program (atexit) or the AtExit object ($exitObject->atexit) and the reference is then returned to the caller (just in case you might want to unregister it later using rmexit. If the given subroutine could not be registered, then the value zero is returned.

The rmexit function/method should be passed one or more subroutine references, each of which was returned by a previous call to atexit. For each argument given, rmexit will look in the list of exit-handling subroutines for the program (rmexit) or the AtExit object ($exitObject->rmexit) and remove the first matching entry from the list. If no arguments are given, then all program or object exit-handlers are unregistered! The value returned will be the number of subroutines that were successfully unregistered.

At object destruction time, the DESTROY{} subroutine in the AtExit module iterates over the subroutine references in the AtExit object and invokes each one in turn (each subroutine is removed from the front of the queue immediately before it is invoked). At program-exit time, the END{} block in the AtExit module iterates over the subroutines in the array returned by the exit_subs method and invokes each one in turn (each subroutine is removed from the front of the queue immediately before it is invoked). Note that in both cases (program-exit, and object-destruction) the subroutines in this queue are invoked in first-to-last order (the reverse order in which they were registered with atexit).

Data::ICal::Entry::Journal is a Perl module that represents a journal entry in an iCalendar file.

SYNOPSIS

my $vjournal = Data::ICal::Entry::Journal->new();
$vjournal->add_properties(
summary => "Minutes of my party",
description => "I cried because I wanted to.",
# Dat*e*::ICal is not a typo here
dtstart => Date::ICal->new( epoch => time )->ical,
);

$calendar->add_entry($vjournal);

A Data::ICal::Entry::Journal object represents a single journal 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::FreeBusy is a Perl module that represents blocks of free and busy time in an iCalendar file.

SYNOPSIS

my $vfreebusy = Data::ICal::Entry::FreeBusy->new();
$vfreebusy->add_properties(
organizer => MAILTO:jsmith@host.com,
# Dat*e*::ICal is not a typo here
freebusy => Date::ICal->new( epoch => ... )->ical . / . Date::ICal->new( epoch => ... )->ical,
);

$calendar->add_entry($vfreebusy);

A Data::ICal::Entry::FreeBusy object represents a request for information about free and busy time or a reponse to such a request, 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.

METHODS

ical_entry_type

Returns VFREEBUSY, its iCalendar entry name.

optional_unique_properties

According to the iCalendar standard, the following properties may be specified at most one time for a free/busy entry:

contact dtstart dtend duration dtstamp
organizer uid url

optional_repeatable_properties

According to the iCalendar standard, the following properties may be specified any number of times for free/busy entry:

attendee comment freebusy request-status

AustinSmoke GasTracker script will allow you to keep track of your gas mileage and have the results displayed in an easy to read website.

None of the data is harvested from anywhere on the web but is rather entered manually by the user and for the user.

Currently the program only supports the English system of miles and gallons. Future versions intend to include the metric system as well as conversions between the figures.

If the demand seems to exist, a future version will allow the user to import a CSV file (or something similar). This should satisfy any users who have historically kept up with such data with Excel and other spreadsheets.

Deep Project is a time entry application for consulting firms. It stores start/end time and sick/vacation time. The project has the beginning of project management and sales cycle features.

Convert::yEnc::Entry is a Perl module as an entry in a Convert::yEnc::RC database.

SYNOPSIS

use Convert::yEnc::Entry;

$entry = new Convert::yEnc::Entry { size => 10000 };
$entry = new Convert::yEnc::Entry { size => 50000, part => 1 };

$entry = load Convert::yEnc::Entry "10000t10000";
$entry = load Convert::yEnc::Entry "20000t1-20000t1-2";

$ok = $entry->ybegin( { size=>10000 } );
$ok = $entry->ypart ( { begin=>1, end=>10000 } );
$ok = $entry->yend ( { size=>10000 } );

$entry->complete and ...

print "$entryn";

ABSTRACT

An entry in a Convert::yEnc::RC database

Convert::yEnc::Entry manages a single entry in a Convert::yEnc::RC database