Free generic software for linux

Libgenerics is a c++ library that provides object services to analyze class type at runtime sharing the definitions between dynamic modules.
It provides serialization services abstraction too. The project is an absolute generic library.
Enhancements:
- autotool layer added

NetServer::Generic is a Perl module that implements an object-oriented
interface for developing internet servers.

Two examples are included:

elizad -- a simple psychotherapy daemon
shttpd -- a really, stupidly, basic HTTP server

A test script, demonstrating client/nonforking operation, is also included.

NetServer::Generic is required by NetServer::SMTP and the leafmail package.

To install NetServer::Generic, follow the usual Perl module installation
practice, viz (probably as root):

cd Generic
perl Makefile.PL
make
make test
make install

NOTE: The test mechanism is slightly non-standard, because NetServer::Generics quit() method interferes with Test::Harness. For this reason, the real test (testguts-forked.pl for the forking server and testguts-preforked.pl for the preforked server) is invoked from within test.pl.

Generic test processor is a language and processor for a language aiming to automatically apply or generate test source code in another language.
It is taken from a library of tests and data conversion operations.
These so generated instances shall be capable of inspecting a system by gathering data and screening this data to meet certain criteria, in other words to have certain attributes.
Enhancements:
- Fixed a bug in results reporting.

POE::Component::Generic is a POE component that provides non-blocking access to a blocking object.

SYNOPSIS

use POE::Component::Generic;

my $telnet = POE::Component::Generic->spawn(

# required; main object is of this class
package => Net::Telnet,

# optional; Options passed to Net::Telnet->new()
object_options => [ ],

# optional; You can use $poco->session_id() instead
alias => telnet,
# optional; 1 to turn on debugging
debug => 1,
# optional; 1 to see the childs STDERR
verbose => 1,

# optional; Options passed to the internal session
options => { trace => 1 },

# optional; describe package signatures
packages => {
Net::Telnet => {
# Methods that require coderefs, and keep them after they
# return.

# The first arg is converted to a coderef
postbacks => { option_callback=>0 }
},
Other::Package => {
# only these methods are exposed
methods => [ qw( one two ) ],

# Methods that require coderefs, but dont keep them
# after they return
callbacks => [ qw( two ) ]
}
}
);

# Start your POE session, then...

$telnet->open( { event => result }, "rainmaker.wunderground.com");
# result state
sub result {
my ($kernel, $ref, $result) = @_[KERNEL, ARG0, ARG1];

if( $ref->{error} ) {
die join( , @{ $ref->{error} ) . "n";
}
print "connected: $resultn";
}


# Setup a postback
$telnet->option_callback( {}, "option_back" );

# option_back state
sub option_back {
my( $obj, $option, $is_remote,
$is_enabled, $was_enabled, $buf_position) = @_[ARG0..$#_];
# See L for a discussion of the above.

# NOTE: Callbacks and postbacks cant currently receive objects.
}

# Use a callback
# Pretend that $other was created as a proxy to an Other::Package object
$other->two( {}, sub { warn "I was called..." } );

my $code = $session->postback( "my_state" );
$other->two( {}, $code );

POE::Component::Generic is a POE component that provides a non-blocking wrapper around any object. It works by forking a child process with POE::Wheel::Run and creating the object in the child process. Method calls are then serialised and sent via STDIN to the child to be handled. Return values are posted back to your session via STDOUT. This means that all method arguments and return values must survive serialisation. If you need to pass coderefs, use "callbacks", "postbacks" or "factories".
Method calls are wrapped in eval in the child process so that errors may be propagated back to your session. See "OUTPUT".

Output to STDERR in the child, that is from your object, is shown only if debug or verbose is set.

STDOUT in the child, that is from your object, is redirected to STDERR and will be shown in the same circomstances.

Finance::QuoteHist::Generic is a base class for retrieving historical stock quotes.

SYNOPSIS

package Finance::QuoteHist::MyFavoriteSite;
use strict;
use vars qw(@ISA);
use Finance::QuoteHist::Generic;
@ISA = qw(Finance::QuoteHist::Generic);

sub url_maker {
# This method returns a code reference for a routine that, upon
# repeated invocation, will provide however many URLs are necessary
# to fully obtain the historical data for a given target mode and
# parsing mode.
}

This is the base class for retrieving historical stock quotes. It is built around LWP::UserAgent. Page results are currently parsed as either CSV or HTML tables.
In order to actually retrieve historical stock quotes, this class should be subclassed and tailored to a particular web site.

In particular, the url_maker() factory method should be overridden, which provides a code reference to a routine that provides however many URLs are necessary to retrieve the data over a list of symbols within the given date range, for a particular target (quotes, dividends, splits). Different sites have different formats and different limitations on how many quotes are returned for each query. See Finance::QuoteHist::Yahoo and Finance::QuoteHist::QuoteMedia for some examples of how to do this.

For more complicated sites, such as Yahoo, overriding additonal methods might be necessary for dealing with things such as splits and dividends.

Generic Hash Table library is a hash table implementation in C for storing arbitrary types of data. Generic Hash Table library is meant to be small, easily extensible (in terms of hash functions etc), and easy to understand codewise.
Enhancements:
- config.guess and config.sub were updated to work with current systems.
- The API was extended with two new functions to allow returning the keysize on iteration.

libapreq is a shared library with associated modules for manipulating client request data via the Apache API.
Generic Apache Request Library also includes language bindings for Perl (Apache::Request and Apache::Cookie). Functionality includes:
parsing of application/x-www-form-urlencoded data
parsing of multipart/form-data
parsing of HTTP cookies
Enhancements:
- This release adds some Perl/C API fixes and build improvements.

PHP Generic Access Control List is a PHP class that offers Web developers a simple, yet immensely powerful "drop in" permission system for their current Web-based applications.
Main features:
- Split into two classes, and a seperate administration interface.
1. GACL class: Designed to be very small (517 lines of code including comments) and very fast, this class strictly takes care of the permission checks.
2. GACL_API class: Designed to be robust and flexible, this class takes care of creating/editing/deleting objects, groups and ACLs.
3. phpGACL Administration Interface: A set of scripts that allow for the easy administration of the entire GACL universe using only your browser.
- NOT limited to typical "read/write/execute" permissions similar to some flavours of *nix
- User definable "Access Control Objects" (ACO). These are objects which control what access is available to "requesters" (see below).
- Several examples:
- Enable - Projects
- View - Projects, View Own - Projects
- Edit - Projects, Edit Own - Projects
- Delete - Projects, Delete Own - Projects, UnDelete - Projects, UnDelete Own - Projects
- Add - Projects
- System down for Maintenance
- View - The letter "e" ;)
- User definable "Access Request Objects" (ARO). These are objects which request access from an "Access Control Object" (above) examples would be:
- Users/Accounts
- IP Addresses
- Browsers/Browser capabilities (JS/Flash/DHTML)
- User definable "Access eXtension Objects" (AXO). These are objects which extend permissions to a 3rd layer, optionally allowing you to set fine grained permissions on each individual item in your application, or even row in your database. AXOs are often used in cases where you only want to give a user access to a specific project or contact.
- Several examples:
- Projects - Project ID: 3474 (Accounting Software)
- Projects - Project ID: 3484 (Financial Software)
- Contacts - Contact ID: 4775 John Doe
- Contacts - Contact ID: 4795 John Doe
- Tree based ARO/AXO Object grouping with inheritance.
- Contains functionality to easily program add-ons. Examples would be for product pricing, or quantity limitations.
- One function application integration: acl_check()
- Simply pass this function four parameters, it doesnt get any easier!
- Supports the most popular databases using the ADODB database abstraction layer. (MySQL, PostgreSQL, Oracle, MSSQL)
- Complete web based administration interface.
- Scalable. A real-world working version with many added layers of complexity supports over 60,000 Accounts, 200 Groups and 300 ACOs.
Requierments:
- PHP 4.x or greater
- SQL database. (MySQL 3x/4.0.15+, PostgreSQL 7.2+, Oracle 9i+, MS-SQL 2000+)
Enhancements:
- This release contains several minor bugfixes and a fix for a major bug with del_object(), which caused transactions to abort prematurely.
- It also contains a slightly improved installer with Informix support, less possibility of conflicting code with other applications, and upgraded ADODB and Smarty packages.