Free class file software for linux

DBIx::Class::Schema::Loader::RelBuilder is a Perl module that builds relationships for DBIx::Class::Schema::Loader.

This class builds relationships for DBIx::Class::Schema::Loader. This is module is not (yet) for external use.

METHODS

new

Arguments: schema_class (scalar), fk_info (hashref), inflect_plural, inflect_singular

$schema_class should be a schema class name, where the source classes have already been set up and registered. Column info, primary key, and unique constraints will be drawn from this schema for all of the existing source monikers.

The fk_info hashrefs contents should take the form:

{
TableMoniker => [
{
local_columns => [ col2, col3 ],
remote_columns => [ col5, col7 ],
remote_moniker => AnotherTableMoniker,
},
# ...
],
AnotherTableMoniker => [
# ...
],
# ...
}

Options inflect_plural and inflect_singular are optional, and are better documented in DBIx::Class::Schema::Loader::Base.

generate_code

This method will return the generated relationships as a hashref per table moniker, containing an arrayref of code strings which can be "eval"-ed in the context of the source class, like:

{
Some::Source::Class => [
"belongs_to( col1 => AnotherTableMoniker )",
"has_many( anothers => AnotherTableMoniker, col15 )",
],
Another::Source::Class => [
# ...
],
# ...
}

You might want to use this in building an on-disk source class file, by adding each string to the appropriate source class file, prefixed by __PACKAGE__->.

Class::ArrayObjects is a Perl utility class for array based objects.

SYNOPSIS

package Some::Class;
use Class::ArrayObjects define => {
fields => [qw(_foo_ _bar_ BAZ)],
};

or

package Other::Class;
use base Some::Class;
use Class::ArrayObjects extend => {
class => Some::Class,
with => [qw(_zorg_ _fnord_ BEZ)],
import => 1,
};

This module is little more than a cute way of defining constant subs in your own package. Constant subs are very useful when dealing with array based objects because they allow one to access array slots by name instead of by index.

Class::Cloneable is a base class for Cloneable objects.

SYNOPSIS

package MyObject;
our @ISA = (Class::Cloneable);

# calling clone on an instance of MyObject
# will give you full deep-cloning functionality

This module provides a flexible base class for building objects with cloning capabilities. This module does its best to respect the encapsulation of all other objects, including subclasses of itself. This is intended to be a stricter and more OO-ish option than the more general purpose Clone and Clone::PP modules.

Class::Adapter::Builder is a Perl module that can generate Class::Adapter classes.

SYNOPSIS

package My::Adapter;

use strict;
use Class::Adapter::Builder
ISA => Specific::API,
METHODS => [ qw{foo bar baz} ],
method => different_method;

1;

Class::Adapter::Builder is another mechanism for letting you create Adapter classes of your own.

It is intended to act as a toolkit for generating the guts of many varied and different types of Adapter classes.

For a simple base class you can inherit from and change a specific method, see Class::Adapter::Clear.

Cgiapp.class.php is a port of CGI::Application to PHP. Cgiapp.class.php utilizes Smarty as its default templating engine, much as CGI::Application uses HTML::Template, due to its prevalence and acceptance in the PHP community.

Due to PHPs built-in session support, it also adds two methods, s_param() and s_delete(), to handle session parameters.

A number of static methods have also been included to facilitate error handling and array/hash conversion.

Class::Delegation is a Perl object-oriented delegation.

SYNOPSIS

package Car;

use Class::Delegation
send => steer,
to => ["left_front_wheel", "right_front_wheel"],

send => drive,
to => ["right_rear_wheel", "left_rear_wheel"],
as => ["rotate_clockwise", "rotate_anticlockwise"]

send => power,
to => flywheel,
as => brake,

send => brake,
to => qr/.*_wheel$/,

send => halt
to => -SELF,
as => brake,

send => qr/^MP_(.+)/,
to => mp3,
as => sub { $1 },

send => -OTHER,
to => mp3,

send => debug,
to => -ALL,
as => dump,

send => -ALL,
to => logger,
;

Class::Std::Utils is a Perl module for utility subroutines for building "inside-out" objects.

SYNOPSIS

use Class::Std::Utils;

# Constructor for anonymous scalars...
my $new_object = bless anon_scalar(), $class;

# Convert an object reference into a unique ID number...
my $ID_num = ident $new_object;

# Extract class-specific arguments from a hash reference...
my %args = extract_initializers_from($arg_ref);

This module provides three utility subroutines that simplify the creation of "inside-out" classes. See Chapters 15 and 16 of "Perl Best Practices" (OReilly, 2005) for details.

WebServerInfo PHP class is intended for developer who create software that will run
on different web servers. The project gives a developer a consistent interface
for accessing web servers variables.

Usage:

You have following options:

Option #1
require_once("WebServerInfo.class.php");
$obj = new WebServerInfo();
print $_SERVER[DOCUMENT_ROOT];

Option #2
require_once("WebServerInfo.class.php");
$obj = new WebServerInfo();
print $obj->get(DOCUMENT_ROOT);

Option #3
uncomment the 3rd line from WebServerInfo.class.php
and all you have to do is require the WebServerInfo.class.php class.

Note:
The constructor of WebServerInfo class overrides $_SERVER variable and
variables can be accessed as usual way.


Following base variables are exported if they do not exist.

REQUEST_URI
REDIRECT_URL
DOCUMENT_ROOT
SERVER_SIGNATURE
SERVER_ADDR
SCRIPT_FILENAME