Free method software for linux

Method::Declarative is a Perl module to create methods with declarative syntax.

SYNOPSIS

use Method::Declarative
(
--defaults =>
{
precheck =>
[
[ qw(precheck1 arg1 arg2) ],
# ...
],
postcheck =>
[
[ qw(postcheck1 arg3 arg4) ],
# ...
],
init =>
[
[ initcheck1 ],
# ...
],
end =>
[
[ endcheck1 ],
# ...
],
once =>
[
[ oncecheck1 ],
] ,
package => __CALLER__::internal,
},
method1 =>
{
ignoredefaults => [ qw(precheck end once) ],
code => __method1,
},
) ;

The Method::Declarative module creates methods in a using class namespace. The methods are created using a declarative syntax and building blocks provided by the using class. This class does not create the objects themselves.

The using class invokes Method::Declarative, passing it list of key-value pairs, where each key is the name of a method to declare (or the special key --default) and a hash reference of construction directives. The valid keys in the construction hash refs are:

code

The value corresponding to code key is a method name or code reference to be executed as the method. It is called like this:

$obj->$codeval(@args)

where $obj is the object or class name being used, $codeval is the coresponding reference or method name, and @args are the current arguments for the invocation. If $codeval is a method name, it needs to be reachable from $obj.

A code key in a method declaration will override any code key set in the --defaults section.

end

The value corresponding to the end key is an array reference, where each entry of the referenced array is another array ref. Each of the internally referenced arrays starts with a code reference or method name. The remaining elements of the array are used as arguments.
Each method declared by the arrays referenced from end are called on the class where the declared method resides in an END block when Method::Declarative unloads.

Each method is called like this:

$pkg->$codeval($name[, @args]);

where $pkg is the package or class name for the method, $name is the method name, and @args is the optional arguments that can be listed in each referenced list.

end blocks are run in the reverse order of method declaration (for example, if method1 is declared before method2, method2s end declaration will be run before method1s), and for each method they are run in the order in which they are declared.

Note that this is not an object destructor, and no objects of a particular class may still exist when these methods are run.

ignoredefaults

The value corresponding to the ignoredefaults key is an array reference pointing to a list of strings. Each string must corespond to a valid key, and indicates that any in-force defaults for that key are to be ignored. See the section on the special --defaults method for details.

init

The value corresponding to the init key is identical in structure to that corresponding to the end key. The only difference is that the declared methods/code refs are executed as soon as the method is available, rather than during an END block.

once

The value corresponding to the once key is identical in structure to that corresponding to the end key. The values are used when the method is invoked, however.

If the method is invoked on an object based on a hash ref, or on the class itself, and it has not been invoked before on that object or hash ref, the methods and code refs declared by this key are executed one at a time, like this:

$obj->$codeval($name, $isscalar, $argsref[, @args ]);

where $obj is the object or class on which the method is being invoked, $codeval is the method name or code reference supplied, $name is the name of the method, $isscalar is a flag to specify if the declared method itself is being executed in a scalar context, $argsref is a reference to the method arguments (@_, in other words), and @args are any optional arguments in the declaration.

The return value of each method or code reference call is used as the new arguments array for successive iterations or the declared method itself (including the object or class name). Yes, that means that these functions can change the the object or class out from under successive operations.

Any method or code ref returning an empty list will cause further processing for the method to abort, and an empty list or undefined value (as appropriate for the context) will be returned as the declared methods return value.

package

The value coresponding to the package key is a string that determines where the declared method is created (which is the callers package by default, unless modified with a --defaults section). The string __CALLER__ can be used to specify the callers namespace, so constructions like the one in the synopsis can be used to create methods in a namespace based on the calling package namespace.

postcheck

The value coresponding to the postcheck key is identical in structure to that coresponding to the end key. The postcheck operations are run like this:

$obj->$codeval($name, $isscalar, $vref[, @args ]);

where $obj is the underlying object or class, $codeval is the method or code ref from the list, $name is the name of the declared method, $isscalar is the flag specifying if the declared method was called in a scalar context, $vref is an array reference of the currently to-be-returned values, and @args is the optional arguments from the list.

Each method or code reference is expected to return the value(s) it wishes to have returned from the method. Returning a null list does NOT stop processing of later postcheck declarations.

precheck

The precheck phase operates similarly to the once phase, except that its triggered on all method calls (even if the underlying object is not a hash reference or a class name).
Any illegal or unrecognized key will cause a warning, and processing of the affected hashref will stop. This means a --defaults section will be ineffective, or a declared method wont be created.

Template::Alloy::VMethod is a Perl module with VMethod role.

The Template::Alloy::VMethod role provides all of the extra vmethods, filters, and virtual objects that add to the base featureset of Template::Alloy. Most of the vmethods listed here are similar to those provided by Template::Toolkit. We will try to keep Template::Alloys in sync. Template::Alloy also provides several extra methods that are needed for HTML::Template::Expr support.

ROLE METHODS

define_vmethod

Defines a vmethod. See Template::Alloy for more details.

vmethod_*

Methods by these names implement virtual methods that are more complex than oneliners. These methods are not exposed via the role.
filter_*

Methods by these names implement filters that are more complex than one liners. These methods are not exposed via the role.

VIRTUAL METHOD LIST

The following is the list of builtin virtual methods and filters that can be called on each type of data.

In Template::Alloy, the "|" operator can be used to call virtual methods just the same way that the "." operator can. The main difference between the two is that on access to hashrefs or objects, the "|" means to always call the virtual method or filter rather than looking in the hashref for a key by that name, or trying to call that method on the object. This is similar to how TT3 will function.

Virtual methods are also made available via Virtual Objects which are discussed in a later section.

Set::Hash is a Perl module with hashes as objects with lots of handy methods (including set comparisons) and support for method chaining.

SYNOPSIS

use Set::Hash;
my $sh1 = Set::Hash->new(name=>"dan",age=>33);
my $sh2 = Set::Hash->new(qw/weight 185 height 72/);
$sh1->length->print; # 2
$sh1->push($sh2); # $sh1 now has weight=>185 and height=>72
$sh1->length->print; # 4
$sh2->values->join(",")->print(1); # 185, 72

Set::Hash allows you to create strings as objects and use OO-style methods on them. Many convenient methods are provided here that appear in the FAQs, the Perl Cookbook or posts from comp.lang.perl.misc. In addition, there are Set methods with corresponding (overloaded) operators for the purpose of Set comparison, i.e. +, ==, etc.

The purpose is to provide built-in methods for operations that people are always asking how to do, and which already exist in languages like Ruby. This should (hopefully) improve code readability and/or maintainability. The other advantage to this module is method-chaining by which any number of methods may be called on a single object in a single statement.

Note that Set::Hash is a subclass of Set::Array, although most of the methods of Set::Array have been overloaded, so youll want to check the documentation for what each method does exactly.

Make-Debian-X11 is an add-on which makes a template with the necessary replacement files for gBootRoots Yard Method.

The root filesystem created from the template is user-mode-linux ready and includes X11, making it possible to run gBootRoot from within its own creation.

Geo::Ellipsoids is a package for standard Geo:: ellipsoid a, b, f and 1/f values.

SYNOPSIS

use Geo::Ellipsoids;
my $obj = Geo::Ellipsoids->new();
$obj->set(WGS84); #default
print "a=", $obj->a, "n";
print "b=", $obj->b, "n";
print "f=", $obj->f, "n";
print "i=", $obj->i, "n";
print "e=", $obj->e, "n";
print "n=", $obj->n(45), "n";

CONSTRUCTOR

new

The new() constructor may be called with any parameter that is appropriate to the set method.

my $obj = Geo::Ellipsoid->new();

METHODS

set

Method sets the current ellipsoid. This method is called when the object is constructed (default is WGS84).

$obj->set(); #default WGS84
$obj->set(Clarke 1866); #All built in ellipsoids are stored in meters
$obj->set({a=>1, b=>1}); #Custom Sphere 1 unit radius
list

Method returns a list of known elipsoid names.

my @list=$obj->list;

my $list=$obj->list;
while (@$list) {
print "$_n";
}
a

Method returns the value of the semi-major axis.

my $a=$obj->a;
b

Method returns the value of the semi-minor axis.

my $b=$obj->b; #b=a(1-f)
f

Method returns the value of flatting

my $f=$obj->f; #f=(a-b)/a
i

Method returns the value of the inverse flatting

my $i=$obj->i; #i=1/f=a/(a-b)
invf

Method synonym for the i method

my $i=$obj->invf; #i=1/f
e

Method returns the value of the first eccentricity, e. This is the eccentricity of the earths elliptical cross-section.

my $e=$obj->e;
e2

Method returns the value of eccentricity squared (e.g. e^2). This is not the second eccentricity, e or e-prime see the "ep" method.

my $e=sqrt($obj->e2); #e^2 = f(2-f) = 2f-f^2 = 1-b^2/a^2
ep

Method returns the value of the second eccentricity, e or e-prime. The second eccentricity is related to the first eccentricity by the equation: 1=(1-e^2)(1+e^2).

my $ep=$obj->ep;
ep2

Method returns the square of value of second eccentricity, e (e-prime). This is more useful in almost all equations.

my $ep=sqrt($obj->ep2); #ep2=(ea/b)^2=e2/(1-e2)=a^2/b^2-1
n

Method returns the value of n given latitude (degrees). Typically represented by the Greek letter nu, this is the radius of curvature of the ellipsoid perpendicular to the meridian plane. It is also the distance from the point in question to the polar axis, measured perpendicular to the ellipsoids surface.

my $n=$obj->n($lat);

Note: Some define a variable n as (a-b)/(a+b) this is not that variable.

n_rad

Method returns the value of n given latitude (radians).

my $n=$obj->n_rad($lat);
rho

rho is the radius of curvature of the earth in the meridian plane.

my $rho=$obj->rho($lat);
rho_rad

rho is the radius of curvature of the earth in the meridian plane.

my $rho=$obj->rho_rad($lat);
polar_circumference

Method returns the value of the semi-minor axis times 2*PI.

my $polar_circumference=$obj->polar_circumference;
equatorial_circumference

Method returns the value of the semi-major axis times 2*PI.

my $equatorial_circumference=$obj->equatorial_circumference;
shortname

Method returns the shortname, which is the hash key, of the current ellipsoid

my $shortname=$obj->shortname;
longname

Method returns the long name of the current ellipsoid

my $longname=$obj->longname;
data

Method returns a hash reference for the ellipsoid definition data structure.

my $datastructure=$obj->data;
name2ref

Method returns a hash reference (e.g. {a=>6378137,i=>298.257223563}) when passed a valid ellipsoid name (e.g. WGS84).

my $ref=$obj->name2ref(WGS84)

Periodic Calendar is a GUI utility which assists in women menstrual cycles tracking and fertility periods prediction.

The information tracked by this application can be used either to became pregnant or to prevent pregnancy.

At this point the fertility prediction is based on the calendar method which is not very precise. It is not recommended to use this method alone for the birth control.

Timestamp::Simple is a Perl module with simple methods for timestamping.

SYNOPSIS

use Timestamp::Simple qw(stamp);
print stamp, "n";

This module provides a simple method for returning a stamp to mark when an event occurs.

METHODS

stamp()

This method returns a timestamp in the form yyyymmddHHMMSS.