Free object oriented analysis software for linux

Object Relational Membrane is a Python package that provides the functionality of an object relational layer like EJB or other persistence storage systems.
Object Relational Membrane is a thin compatibility layer between SQL table layouts and Object Oriented Python. While providing a good deal of functionality, it tries to be as small and simple as possible. It currently works with PostgreSQL and Gadfly.
Adapters for Firebird and MySQL are planed.
Enhancements:
- A number of small changes and enhancements.
- The last release previous to a "beta" release.

Php Object Generator on short POG is an open source PHP code generator which automatically generates clean & tested Object Oriented code for your PHP4/PHP5 application.
Over the years, we realized that a large portion of a PHP programmers time is wasted on repetitive coding of the Database Access Layer of an application simply because different applications require different objects.
By generating PHP objects with integrated CRUD methods, POG gives you a head start in any project and saves you from writing and testing SQL queries. The time you save can be spent on more interesting areas of your project. But dont take our word for it, give it a try!
Main features:
- Generates clean & tested code
- Generates CRUD methods
- Compatible with PHP4 & PHP5
- Compatible with PDO
- Free for personal use
- Free for commercial use
- Open Source
Enhancements:
- POG now fetches result set arrays where possible (which provides a big performance boost).
- Data encoding is handled within the database.
- A new plugin interface is used.
- A data encoding sanity check was added to setup.
- Siblings can be deleted without deleting children.
- Getlist() accepts column names as filters.
- Getlist(), GetChild(), and GetSibling() return all results if no arguments are passed.
- A database wrapper class for PDO was added.
- The PDO performance was improved.
- The plugin API, POG base API, and database API were made uniform to prevent plugin versioning.

Fedora Digital Object Repository is an open source software which gives organizations a flexible service-oriented architecture for managing and delivering their digital content. At its core is a powerful digital object model that supports multiple views of each digital object and the relationships among digital objects.
Digital objects can encapsulate locally-managed content or make reference to remote content. Dynamic views are possible by associating web services with objects. Digital objects exist within a repository architecture that supports a variety of management functions. All functions of Fedora, both at the object and repository level, are exposed as web services. These functions can be protected with fine-grained access control policies.
This unique combination of features makes Fedora an attractive solution in a variety of domains. Some examples of applications that are built upon Fedora include library collections management, multimedia authoring systems, archival repositories, institutional repositories, and digital libraries for education.
Enhancements:
- This is a significant release of Fedora that includes a complete repackaging as a proper Web application.
- A new installer application makes it easy to setup and run.
- It now uses Servlet Filters for authentication.
- The Fedora repository can also be configured to calculate and store checksums for content.
- The RDF-based Resource Index has been tuned for better performance.
- A new high-performing RDBMS-backed triplestore has been developed that can now be plugged into the RI.

Tree::Binary is a Object Oriented Binary Tree for Perl.

SYNOPSIS

use Tree::Binary;

# a tree representaion of the expression:
# ((2 + 2) * (4 + 5))
my $btree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);
# Or shown visually:
# +---(*)---+
# | |
# +-(+)-+ +-(+)-+
# | | | |
# (2) (2) (4) (5)

# get a InOrder visitor
my $visitor = Tree::Binary::Visitor::InOrderTraversal->new();
$btree->accept($visitor);

# print the expression in infix order
print $visitor->getAccumulation(); # prints "2 + 2 * 4 + 5"

# get a PreOrder visitor
my $visitor = Tree::Binary::Visitor::PreOrderTraversal->new();
$btree->accept($visitor);

# print the expression in prefix order
print $visitor->getAccumulation(); # prints "* + 2 2 + 4 5"

# get a PostOrder visitor
my $visitor = Tree::Binary::Visitor::PostOrderTraversal->new();
$btree->accept($visitor);

# print the expression in postfix order
print $visitor->getAccumulation(); # prints "2 2 + 4 5 + *"

# get a Breadth First visitor
my $visitor = Tree::Binary::Visitor::BreadthFirstTraversal->new();
$btree->accept($visitor);

# print the expression in breadth first order
print $visitor->getAccumulation(); # prints "* + + 2 2 4 5"

# be sure to clean up all circular references
$btree->DESTROY();

This module is a fully object oriented implementation of a binary tree. Binary trees are a specialized type of tree which has only two possible branches, a left branch and a right branch. While it is possible to use an n-ary tree, like Tree::Simple, to fill most of your binary tree needs, a true binary tree object is just easier to mantain and use.

Binary Tree objects are especially useful (to me anyway) when building parse trees of things like mathematical or boolean expressions. They can also be used in games for such things as descisions trees. Binary trees are a well studied data structure and there is a wealth of information on the web about them.

This module uses exceptions and a minimal Design By Contract style. All method arguments are required unless specified in the documentation, if a required argument is not defined an exception will usually be thrown. Many arguments are also required to be of a specific type, for instance the $tree argument to both the setLeft and setRight methods, must be a Tree::Binary object or an object derived from Tree::Binary, otherwise an exception is thrown. This may seems harsh to some, but this allows me to have the confidence that my code works as I intend, and for you to enjoy the same level of confidence when using this module. Note however that this module does not use any Exception or Error module, the exceptions are just strings thrown with die.

This object uses a number of methods copied from another module of mine, Tree::Simple. Users of that module will find many similar methods and behaviors. However, it did not make sense for Tree::Binary to be derived from Tree::Simple, as there are a number of methods in Tree::Simple that just wouldnt make sense in Tree::Binary. So, while I normally do not approve of cut-and-paste code reuse, it was what made the most sense in this case.

Porcupine is a web application server that provides an object oriented framework for developing web applications rapidly.

Many of the tasks required for building web applications as you know them, are either eliminated or simplified. For instance, when developing a Porcupine application you dont have to design a relational database. You only have to design and implement your business objects as classes, using the building blocks provided by the framework (datatypes). Porcupine integrates a native object database, no mapping required.

Another tedious task for web applications is the interface design, and the constraints imposed by HTML. QuiX, the servers integrated XUL motor, simplifies the interface design process. All you have to do is describe your applications interface in XML and write the appropriate event handlers. You dont have to waste time and money on widget implementations. QuiX comes with a variety of ready to use widgets, accelerating the development process.

Generally, every Porcupine application consists of three distinct layers. The first is the business layer consisting of the business objects which encapsulate the business logic.
The second layer binds the HTTP protocol with the first layers business objects. This layer is implemented using Python Server Pages or Servlets. If using XML-RPC, one common approach is to directly map an XML-RPC method to a business objects method.
The third layer, the presentation layer, usually consists of XML UI definitions and JavaScript event handlers.

The first two layers are executed server side and the third layer is executed on the client (browser).

JDOInstruments is an embedded object oriented database programmed in java, it is also an implementation of Suns Java Data Objects (JDO) specification for the transparent persistence of Java objects.
Because of this, it doesnt need a JDBC driver or a relational database. JDOInstruments uses its own object store thus it allows storage and retrieval of persistent data with little work from you.
It is integrated with Netbeans IDE (via Plugin module) allowing developers to build pure object-oriented systems.
It is free and Our license is GNU LGPL providing the code and executables (JARs) free of charge. You are free to use JDOInstruments in your projects.
Main features:
- Byte-Code Enhancement of classes
- Byte-Code Compatibility
- Datastore identity
- Optimistic Transaction
- Nontransactional Read
- Retain values
- Restore values
- Second Class PersistenceCapable objects
- J2EE Integration
- Query (JDOQL)
- Index
- Schema Evolution

Algorithm::Permute is a Perl module with handy and fast permutation with object oriented interface.

SYNOPSIS

use Algorithm::Permute;

my $p = new Algorithm::Permute([a..d]);
while (@res = $p->next) {
print join(", ", @res), "n";
}

my @array = (1..9);
Algorithm::Permute::permute { print "@arrayn" } @array;

This handy module makes performing permutation in Perl easy and fast, although perhaps its algorithm is not the fastest on the earth. Currently it only supports permutation n of n objects.

No exported functions. This version is not backward compatible with the previous one, version 0.01. The old interface is no longer supported.

METHODS

new [@list]

Returns a permutor object for the given items.

next

Returns a list of the items in the next permutation. The order of the resulting permutation is the same as of the previous version of Algorithm::Permute.

peek

Returns the list of items which will be returned by next(), but doesnt advance the sequence. Could be useful if you wished to skip over just a few unwanted permutations.

reset

Resets the iterator to the start. May be used at any time, whether the entire set has been produced or not. Has no useful return value.