Free persistence hunting software for linux

Persistent::DBI is an Abstract Persistent Class implemented using a DBI Data Source.

SYNOPSIS

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

ABSTRACT

This is an abstract class used by the Persistent framework of classes to implement persistence using DBI data stores. This class provides the methods and interface for implementing Persistent DBI 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 DBI 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.

Lexical::Persistence is a Perl module for persistent lexical variable values for arbitrary calls.

SYNOPSIS

#!/usr/bin/perl

use Lexical::Persistence;

my $persistence = Lexical::Persistence->new();
foreach my $number (qw(one two three four five)) {
$persistence->call(&target, number => $number);
}

exit;

sub target {
my $arg_number; # Argument.
my $narf_x++; # Persistent.
my $_i++; # Dynamic.
my $j++; # Persistent.

print "arg_number = $arg_numbern";
print "tnarf_x = $narf_xn";
print "t_i = $_in";
print "tj = $jn";
}

Mergence is a high performance, open source HL7integration engine and application platform. It was developed to fill the need for an open source, fully transactional healthcare integration system capable of handling millions of messages per day, and thousands of concurrent LLP connections. Mergence is based on Apache ServiceMix, a lightweight enterprise service bus which conforms to the JBI standard, and HAPI, an excellent opensource HL7v2 API. We plan to support HL7v3 in the next release.
Mergence is still in heavy development, and documentation is still lacking, but the current release is already production-ready if you dont mind working with some XML. We have a well-tested and solid core in place, which is fully usable. Development of an AJAX administration console is underway and is the main focus of the 2.0 release.
We hope to have more complete documentation available in the next week.
Main features:
- Fully open source, under the GNU General Public License
- Built on standards-based technologies.
- End-to-end persistence with global transactions so no message can ever be lost.
- High-throughput, asynchronous architecture.
- Message vault with encrypted storage (embedded or external DB).
- Flexible message routing and transformation.
- Scriptable using Groovy
- Extensive logging, monitoring, and alerting system.
- Supports active clustering.
- Many bundled connectors, and compatible with any ServiceMix JBI component.
- NIO TCP connectors which can support thousands of concurrent connections.
- Support for processing/transforming flat files of unlimited size.
- Hot deployment of new components and configurations.
- JBI extensions for easily developing new HL7 components.

Cyphesis is a WorldForge server suitable running small games. Cyphesis is also designed by be used as an AI subsystem in a network of distributed servers.
It includes a terrain engine based on the Mercator library, a persistence system based on PostgreSQL, and an AI engine using goal trees implemented in Python. It is the server used in most current WorldForge games.
Current releases of cyphesis use the re-written C++ core, based on the design of the original python core.
Enhancements:
- The way rules data is handled is now much simpler to make it easier for game designers to create what they want.
- A lot of hard-coded functionality has been removed from the compiled core program.
- Core functionality is now associated with properties, and so can be applied to any entity.
- Most of Mason has been reimplemented as task scripts, which are cleaner and more flexible.
- There are more helpful messages when inconsistencies are detected in rule data.
- This release works more reliably as an autopackage.

Open Tranquera is a repository of reusable components for J2EE application development.

There are UI extensions, Services, and a Persistence layer, integrated with existing open source frameworks.

OpenChronicle is a real world blogging application with basic functionality similar to websites such as Blogger, WordPress, LiveJournal and MySpace.
OpenChronicles purpose is to demonstrate how to use individual subsystems available as part of OpenSubsystems project when developing Java applications. It is an excellent learning resource for those who want to master the available subsystems or maybe just want to quickly lookup how to use some particular feature.
The detailed tutorials document every step of design and development process that is required to quickly create fully featured application that is portable and easily maintainable. Each successive version expands the previous one with desirable features that are implemented easily by integrating another available subsystem or some aspect of its functionality.
Enhancements:
- OpenChronicle is a comprehensive tutorial to development of Java applications using Open Core middleware abstraction layer.
- The tutorial walks the developer through the design and implementation of a real world blogging application.
- It describes how to easily implement the application data model, code persistence working with any of the supported databases, make the application work as a POJO or EJB using any of the supported J2EE application servers, and how to design a flexible, skinnable Web user interface with basic security features.

DB_DataContainer is a PEAR compliant database persistence layer and data encapsulation class. A persistence layer can encapsulate the behaviour needed to make objects persistent like for exemple: to load, save and delete objects to and from persistent storage. Currently the only supported persistence mechanisms are relational databases. Database abstraction is provided by PEAR DB.
Data encapsulation is provided by overloaded accessor methods. This means that if you have a property named $foo and you do not write getFoo() and setFoo() methods in the extending class yourself, they will be automatically provided by DB_DataContainer.
As a result of the provided persistence mechanism and data encapsulation DB_DataContainer together with few lines of extra code can be used to implement the Active Record Pattern as described by Martin Fowler:
An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.
The class does not use any external configuration files. The extending class itself IS the configuration. All you need to take care about is to have matching propertyname - columname pairs in the class and the database table.
If your database schema changes, for example you add an column foo to the table, all you need to do is to add a property name foo to your class which extends DB_DataContainer. There is no need to rewrite any internal SQL queries.
The class does not provide direct support for JOIN:s or table linking. For extreme cases it is still possible to pass hardcoded SQL queries. This usage is discouraged since it breaks the basic idea of using DB_DataContainer.
Main features:
- Simple API
- Persistence mechanism encapsulation. You only need to call load(), save() or delete(). Note that there are no separate methods for INSERT and UPDATE. save() figures itself out which query to use.
- Overloaded accessor methods for class properties without such methods.
- PEAR DB supported databases as persistence mechanisms (tested with Postgres, MySQL, MSSQL and SQLite).
- Multi-object actions provided by a static getObjects() call.
- Possibility to use hardcoded SQL queries in multi-object actions.
- Regression tests.
- Supports PHP4 and PHP5 (starting from version 1.3.0)
Enhancements:
- This release fixes problems with protected and private data members when using PHP5.