This module provides a 'Local Mean Time' timezone for DateTime. Using it you
can determine the Mean Time for any location on Earth. Note however that the
Mean Time and the Apparent Time (where the sun is in the sky) differ from day
to day. This module may account for Local Apparent Time in the future but then
again, the Solar:: modules will probably be a better bet.
If you want more information on the difference between LMT and LAT, search the
www for 'equation of time' or 'ephemeris'.
Dist::Zilla builds distributions of code to be uploaded to the CPAN.
In this respect, it is like ExtUtils::MakeMaker, Module::Build, or
Module::Install. Unlike those tools, however, it is not also a
system for installing code that has been downloaded from the CPAN.
Since it's only run by authors, and is meant to be run on a repository
checkout rather than on published, released code, it can do much
more than those tools, and is free to make much more ludicrous
demands in terms of prerequisites.
Often Perl modules are written to wrap functionality found in existing C
headers, libraries, or to use OS-specific features. It is useful in the Build.PL
or Makefile.PL file to check for the existance of these requirements before
attempting to actually build the module.
Objects in this class provide an extension around ExtUtils::CBuilder to simplify
the creation of a .c file, compiling, linking and running it, to test if a
certain feature is present.
It may also be necessary to search for the correct library to link against, or
for the right include directories to find header files in. This class also
provides assistance here.
File::NFSLock - perl module to do NFS (or not) locking.
The module is based of concept of hard linking of files being atomic
across NFS. This concept was mentioned in Mail::Box::Locker (which was
originally presented in Mail::Folder::Maildir). Some routine flow is
taken from there -- particularly the idea of creating a random local
file, hard linking a common file to the local file, and then checking
the nlink status. Some ideologies were not complete (uncache mechanism,
shared locking) and some coding was even incorrect (wrong stat index).
File::NFSLock was written to be light, generic, and fast.
This is yet another module that lets you access or change the elements
of a hash using methods with the same name as the element's key. It
follows in the footsteps of Hash::AsObject, Hash::Inflator,
Data::OpenStruct::Deep, Object::AutoAccessor, and probably others. The
main difference between this module and its forebears is that it
supports tied hashes, in addition to regular hashes. This allows a
modular division of labor: this class is generic and treats all hashes
the same; any special semantics come from the tied hash.
Hash::Merge::Simple will recursively merge two or more hashes and
return the result as a new hash reference. The merge function will
descend and merge hashes that exist under the same node in both the
left and right hash, but doesn't attempt to combine arrays, objects,
scalars, or anything else. The rightmost hash also takes precedence,
replacing whatever was in the left hash if a conflict occurs.
This code was pretty much taken straight from Catalyst::Utils, and
modified to handle more than 2 hashes at the same time.
The Inline::Java module allows you to put Java source code directly "inline"
in a Perl script or module. A Java compiler is launched and the Java code is
compiled. Then Perl asks the Java classes what public methods have been
defined. These classes and methods are available to the Perl program as if
they had been written in Perl.
The process of interrogating the Java classes for public methods occurs the
first time you run your Java code. The namespace is cached, and subsequent
calls use the cached version.
This module provides a number of list utility functions, all of which
take an initial code block to control their behaviour. They are
variations on similar core perl or List::Util functions of similar
names, but which use the block to control their behaviour. For
example, the core Perl function sort takes a list of values and
returns them, sorted into order by their string value. The sort_by
function sorts them according to the string value returned by the
extra function, when given each value.
The Inline::Tcl module allows you to put Tcl source code directly
"inline" in a Perl script or module. A Tcl interpreter is loaded and the
Tcl code is interpreted, then Perl asks the Tcl interpreter which global
procedures have been defined. Those functions are made available to your
Perl program as if they had been written in Perl.
The process of interrogating the Tcl interpreter for globals only occurs
the first time you run your Tcl code. The namespace is cached, and
subsequent calls use the cached version.
Perl module for static variables without namespace pollution
Lexical::Var and Lexical::Sub implement lexical scoping of static variables and
subroutines. Although it can be used directly, it is mainly intended to be
infrastructure for modules that export particular objects.
Lexical::Var only manages variables of static duration (the kind of duration
that our and state variables have). To get a fresh variable for each invocation
of a function, use my.
Lexical::Sub is implemented through the mechanism of Lexical::Var. Its distinct
name and declaration syntax exist to make lexical subroutine declarations
clearer.