Free persistent class software for linux

Persistent::Base is an Abstract Persistent Base Class.

SYNOPSIS

### we are a subclass of ... ###
use Persistent::Base;
@ISA = qw(Persistent::Base);

ABSTRACT

This is an abstract class used by the Persistent framework of classes to implement persistence with various types of data stores. This class provides the methods and interface for implementing Persistent classes. Refer to the Persistent documentation for a very thorough introduction to using the Persistent framework of classes.

This class is part of the Persistent base package which is available from:

http://www.bigsnow.org/persistent
ftp://ftp.bigsnow.org/pub/persistent

Before we get started describing the methods in detail, it should be noted that all error handling in this class is done with exceptions. So you should wrap an eval block around all of your code. Please see the Persistent documentation for more information on exception handling in Perl.

ABSTRACT METHODS THAT NEED TO BE OVERRIDDEN IN THE SUBCLASS

datastore -- Sets/Returns the Data Store Parameters

eval {
### set the data store ###
$person->datastore(@args);

### get the data store ###
$href = $person->datastore();
};
croak "Exception caught: $@" if $@;

Returns (and optionally sets) the data store of the object. This method throws Perl execeptions so use it with an eval block.

Setting the data store can involve anything from initializing a connection to opening a file. Getting a data store usually means returning information pertaining to the data store in a useful form, such as a connection to a database or a location of a file.

Persistent::Oracle is a persistent class implemented using an Oracle database.

SYNOPSIS

use Persistent::Oracle;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $emp = new Persistent::Oracle(dbi:Oracle:ORCL,
scott, tiger, emp);

### define attributes of the object ###
$emp->add_attribute(empno, ID, Number, undef, 4);
$emp->add_attribute(ename, Persistent, VarChar, undef, 10);
$emp->add_attribute(job, Persistent, VarChar, undef, 9);
$emp->add_attribute(mgr, Persistent, Number, undef, 4);
$emp->add_attribute(hiredate, Persistent, DateTime, undef);
$emp->add_attribute(sal, Persistent, Number, undef, 7, 2);
$emp->add_attribute(comm, Persistent, Number, undef, 7, 2);
$emp->add_attribute(deptno, Persistent, Number, undef, 2);

### query the datastore for some objects ###
$emp->restore_where(qq{
sal > 1000 and
job = CLERK and
ename LIKE M%
}, "sal, ename");
while ($emp->restore_next()) {
printf "ename = %s, emp# = %s, sal = %s, hiredate = %sn",
$emp->ename, $emp->empno, $emp->sal, $emp->hiredate;
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses an Oracle database table to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Persistent::mSQL is a persistent class implemented using a mSQL database.

SYNOPSIS

use Persistent::mSQL;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $emp = new Persistent::mSQL($data_source, undef, undef, $table);

### define attributes of the object ###
$emp->add_attribute(empno, ID, Number, undef, 4);
$emp->add_attribute(ename, Persistent, VarChar, undef, 10);
$emp->add_attribute(job, Persistent, VarChar, undef, 9);
$emp->add_attribute(mgr, Persistent, Number, undef, 4);
$emp->add_attribute(hiredate, Persistent, DateTime, undef);
$emp->add_attribute(sal, Persistent, Number, undef, 7, 2);
$emp->add_attribute(comm, Persistent, Number, undef, 7, 2);
$emp->add_attribute(deptno, Persistent, Number, undef, 2);

### query the datastore for some objects ###
$emp->restore_where(qq{
sal > 1000 and
job = CLERK and
ename LIKE M%
}, "sal, ename");
while ($emp->restore_next()) {
printf "ename = %s, emp# = %s, sal = %s, hiredate = %sn",
$emp->ename, $emp->empno, $emp->sal, $emp->hiredate;
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses a mSQL database table to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Basset::Object::Persistent is a subclass of Basset::Object that allows objects to be easily stored into a relational database. Presently only supports MySQL, but that may change in the future.

SYNOPSIS

(no synopsis, this is an abstract super class that should never be instantiated directly, it should be subclassed for all persistent objects and used through them)

Basset::Object is the uber module in my Perl world. All objects should decend from Basset::Object. It handles defining attributes, error handling, construction, destruction, and generic initialization. It also talks to Basset::Object::Conf to allow conf file use.
But, some objects cannot simply be recreated constantly every time a script runs. Sometimes you need to store the data in an object between uses so that you can recreate an object in the same form the last time you left it. Storing user information, for instance.

Basset::Object::Persistent allows you to do that transparently and easily. Persistent objects need to define several pieces of additional information to allow them to commit to the database, including their table definitions. Once these items are defined, youll have access to the load and commit methods to allow you to load and store the objects in a database.

It is assumed that an object is stored in the database in a primary table. The primary table contains a set of columns named the same as object attributes. The attributes are stored in those columns.

Some::Package->add_attr(foo);
my $obj = Some::Package->new();
$obj->foo(bar);
$obj->commit();

in the database, the foo column will be set to bar.

PHP Greeting card class can be used to compose and send greeting cards by email.

PHP Greeting card class can compose and send an email message with a greeting either in text, in HTML with an image, or in HTML with Flash content.

The HTML version of the card may include a greeting picture.

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

Exception::Class is a Perl module that allows you to declare real exception classes in Perl.

SYNOPSIS

use Exception::Class
( MyException,

AnotherException =>
{ isa => MyException },

YetAnotherException =>
{ isa => AnotherException,
description => These exceptions are related to IPC },

ExceptionWithFields =>
{ isa => YetAnotherException,
fields => [ grandiosity, quixotic ],
alias => throw_fields,
},
);

# try
eval { MyException->throw( error => I feel funny. ) };

my $e;
# catch
if ( $e = Exception::Class->caught(MyException) )
{
warn $e->error, "n", $e->trace->as_string, "n";
warn join , $e->euid, $e->egid, $e->uid, $e->gid, $e->pid, $e->time;

exit;
}
elsif ( $e = Exception::Class->caught(ExceptionWithFields) )
{
$e->quixotic ? do_something_wacky() : do_something_sane();
}
else
{
$e = Exception::Class->caught();
ref $e ? $e->rethrow : die $e;
}

# use an alias - without parens subroutine name is checked at
# compile time
throw_fields error => "No strawberry", grandiosity => "quite a bit";

Exception::Class allows you to declare exception hierarchies in your modules in a "Java-esque" manner.

It features a simple interface allowing programmers to declare exception classes at compile time. It also has a base exception class, Exception::Class::Base, that can be easily extended.

It is designed to make structured exception handling simpler and better by encouraging people to use hierarchies of exceptions in their applications, as opposed to a single catch-all exception class.

This module does not implement any try/catch syntax. Please see the "OTHER EXCEPTION MODULES (try/catch syntax)" section for more information on how to get this syntax.