Free object oriented interface software for linux

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.

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.

Chart::Scientific is a Perl module that can generate simple 2-D scientific plots with logging, errbars, etc.

SYNOPSIS

Procedural interface

use Chart::Scientific qw/make_plot/;
make_plot ( x_data => @x_values, y_data => @yvalues );

The subroutine make_plot creates a Chart::Scientific object passing along every argument it was given. See OPTIONS below for a full list of allowed arguments.
Object Oriented interface

Plot data from two arrays:

use Chart::Scientific;
my $plt = Chart::Scientific->new (
x_data => @x_values,
y_data => @y_values,
);
$plt->plot ();
or piddles:
use Chart::Scientific;
my $plt = Chart::Scientific->new (
x_data => $x_pdl,
y_data => $y_pdl,
);
$plt->plot ();
Plot data from an arbitrarily-delimitted file (the data in columns "vel" and "acc" vs the data in the column "time", with errorbars from the columns "vel_err" and "acc_err"):
my $plt = Chart::Scientific->new (
filename => data.tab-separated,
split => t,
x_col => time,
y_col => vel,acc,
err_col => vel_err,acc_err,
x_label => "time",
y_label => "velocity and acceleration",
);
$plt->plot ();
Plot data in arrays:
my $plt = Chart::Scientific->new (
x_data => @height,
y_data => [ @weight, @body_mass_index ],
);
$plt->plot ();
Plot data in pdls:
my $plt = Chart::Scientific->new (
x_data => $pdl_x,
y_data => [ $pdl_y1, $pdl_y2 ],
);
$plt->plot ();
Plot the above data to a file:
my $plt = Chart::Scientific->new (
x_data => $pdl_x,
y_data => [ $pdl_y1, $pdl_y2 ],
device => myplot.ps/cps,
);
$plt->plot ();
Generate multiple plots with the same object:
my @x1 = 10..19;
my @y1 = 20..29;
my @y2 = 50..59;

my $plt = Chart::Scientific->new (
x_data => @x1,
y_data => @y1,
x_label => "test x",
y_label => "test y",
);
$plt->setvars ( title => testa, device => 1/xs );
$plt->plot ();

$plt->setvars ( title => testb, device => 2/xs );
$plt->plot ();

Undisposable Clients project provides easy-to-use API kits for using Undisposable.org in various programming languages.
Main features:
- Protects site owners biggest assets; userbase and emails
- Prevents userbase contamination by fake accounts
- As critical as email validity check
- Stops people registering your services with disposable email accounts like jetable.org, pookmail
- Detects public accounts (spread from sites like bugmenot.com) and bans them
- Working principle is similar to spam blacklists like spamhaus.org; power of masses
- Totally free, your donations are welcome
How to use it
Check if there is an API kit for your programming language, if there isnt, connect to our servers manually.
Add a few extra lines to your email validation function which is called from your member registration page. The following is an example in PHP language:
..
function checkEmail($email) {
include_once("undorg/php/rest/undisposable.inc.php"); // include the API kit
if(!undorg_isDisposableEmail($email)) { // check if disposable email
.. // old procedures remain here
} // add this line to close the conditional statement
}
..
?>
Thats all. Very simple...
API kits:
PHP
Supports XML-RPC, REST and PHP serialiation. Stable
@TODO: make it object oriented, test PHP5
Python
Supports XML-RPC. Stable
@TODO: make it object oriented, more protocols
Perl
Supports XML-RPC. Beta
@TODO: test it, make it object oriented, more protocols
Java
Supports XML-RPC. Alpha
@TODO: test it, make it object oriented, more protocols
We need your support for clients in other languages.
Enhancements:
- The isValidEmail function was added for PHP and Python.
- Valid RFC and TLD checks are made in real time, as well blacklist queries against disposable email addressing and public accounts from sites similar to bugmenot.com.

Turtle3D project is a scheme implementation of the Turtle, in 3D.

It is object oriented, so you can have many turtles in the drawing window.

A test program is included.

Netscape::Cache is a Perl object class for accessing Netscape cache files.

SYNOPSIS

The object oriented interface:

use Netscape::Cache;

$cache = new Netscape::Cache;
while (defined($url = $cache->next_url)) {
print $url, "n";
}

while (defined($o = $cache->next_object)) {
print
$o->{URL}, "n",
$o->{CACHEFILE}, "n",
$o->{LAST_MODIFIED}, "n",
$o->{MIME_TYPE}, "n";
}

The TIEHASH interface:

use Netscape::Cache;

tie %cache, Netscape::Cache;
foreach (sort keys %cache) {
print $cache{$_}->{URL}, "n";
}

The Netscape::Cache module implements an object class for accessing the filenames and URLs of the cache files used by the Netscape web browser.

Note: You can also use the undocumented pseudo-URLs about:cache, about:memory-cache and about:global-history to access your disk cache, memory cache and global history.
There is also an interface for using tied hashes.

Netscape uses the old Berkeley DB format (version 1.85) for its cache index index.db. Version 2.x.x is incompatible with the old format (db_intro(3)), so you have either to downgrade or to convert the database using db_dump185 and db_load. See convert_185_2xx for a (experimental) converter function.

Rudiments is a C++ class library providing base classes for things such as daemons, clients, and servers, and wrapper classes for the standard C functions for things like semaphores, regular expressions, and signal handling.
In the early days of SQL Relay and Groundwork, some of the classes being developed for each project didnt exactly fit. Or more precisely, could concievably be useful in other projects. Some of these classes were very generic base classes, others were utilities. The older the projects got, the more obvious it became that these classes should be extracted and assembled into a library of their own.
Rudiments was born.
As a result, some of the rudiments classes are fairly full featured and others very incomplete; containing only the functions that were required by the project they were derived from.
Rudiments is very much a work in progress, and not extremely well defined at that. Currently though, the objective of the project is to develop a set of utility classes that provide the functionality of the standard C libraries through an object oriented interface and a set of useful base classes for some standard kinds of programs.
Enhancements:
- This release fixes several memory leaks, a vulnerability in readdir_r, and a few additional methods in several classes.