Free active object software for linux

Active Objects is an implementation of the Active Object concept based on the boost::thread, boost::bind, and boost::function libraries.
The point of the library is to make taking advantage of multiprocessor machines as easy as possible. The library provides two types of functionality. The first is the ability to execute a function in a separate thread and automatically synchronize with the thread when the return value is needed.
The second is the ability to easily create a message cue for any existing class, and have that class process its messages asynchronously.
Enhancements:
- Minor code cleanup and code documentation updates.

Games::Object is a Perl module to provide a base class for game objects.

SYNOPSIS

package MyGameObject;
use Games::Object;
use vars qw(@ISA);
@ISA = qw(Games::Object);

sub new {
# Create object
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new(@_);
bless $self, $class;

# Add attributes
$self->new_attr(-name => "hit_points",
-type => int,
-value => 20,
-tend_to_rate => 1);
$self->new_attr(-name => "strength",
-type => int,
-value => 12,
-minimum => 3,
-maximum => 18);
...

return $self;
}

package MyObjectManager;
use Games::Object::Manager;
use vars qw(@ISA);
@ISA = qw(Games::Object::Manager);

sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new( , @_);
bless $self, $class;
...
return $self;
}


my $world = new MyObjectManager;
my $object = new MyGameObject;
$world->add($object);

ABSTRACT

The purpose of this module is to allow a programmer to write a game in Perl easily by providing a basic framework in the form of a module that can be either subclassed to a module of your own or used directly as its own object class. The most important items in this framework are:

Attributes

You can define arbitrary attributes on objects with rules on how they may be updated, as well as set up automatic update of attributes whenever the objects process() method is invoked. For example, you could set an attribute on an object such that:

It ranges from 0 to 100.

Internally it tracks fractional changes to the value but accessing the attribute will always round the result to an integer.

It will automatically tend towards the maximum by 1 every time process() is called on the object.

A method in your subclass will be invoked automatically if the value falls to 0.
This is just one example of what you can do with attributes.

Flags

You can define any number of arbitrarily-named flags on an object. A flag is a little like a boolean attribute, in that it can have a value of either true or false. Like attributes, flags can be created independently on different objects. No "global" flag list is imposed.

Load/Save functionality

Basic functionality is provided for saving data from an object to a file, and for loading data back into an object. This handles the bulk of load game / save game processing, freeing the programmer to worry about the mechanics of the game itself.

The load functionality can also be used to create objects from object templates. An object template would be a save file that contains a single object.

Object Managers

New to version 0.10 of this module is object managers. An object manager is a Perl object that allows you to manage groups of related game objects. The object manager allows you to relate objects together (for example, you could define a relationship that allows certain objects to act as containers for other objects). In effect, the object manager acts as your world or universe.
Like the game object class, the manager class can be subclassed, allowing you augment its functionality. An object manager can be loaded and saved, which in turn performs a load or save of the objects being managed by it.

This is an excellent widget set for Tcl which retains much of the Tk syntax, but uses curses to render the widgets in a character-cell terminal instead of X and a graphical display.

Installation

1. Type "./configure". This runs a configuration script made by GNU autoconf, which configures Ck for your system and creates a Makefile. The configure script allows you to customize the configuration to your local needs; for details how to do this, type "./configure --help" or refer to the autoconf documentation (not included here).

The following special switches are supported by "configure":

--enable-shared If this switch is specified Ck will compile itself as a shared library if configure can figure out how to do this on this platform.

--with-tcl Specifies the directory containing the Tcl binaries and Tcls platform-dependent configuration information. By default the Tcl distribution is assumed to be in "../../tcl8.0".

2. Type "make". This will create a library called "libck.a" or "libck8.0.so" and an interpreter application called "cwsh" that allows you to type Tcl commands interactively or execute scripts.

3. Type "make install" to install Cks binaries, script files, and man pages in standard places. Youll need write permission on the install directories to do this. If you plan to install the libraries, executables, and script files whitout documentation, use "make install-binaries" and "make install-libraries".

4. Now you should be able to execute "cwsh". However, if you havent installed Ck then youll need to set the CK_LIBRARY environment variable to hold the full path name of the "library" subdirectory. If Ck has been built as shared library, you have to set the LD_LIBRARY_PATH to include the directory where "libck8.0.so" resides.

So far, Ck8.0 has been successfully tested on various Linux distributions, on FreeBSD 3.3 with manually adapted Makefile, and on Windows NT 4.0 with a modified PDCURSES library. The Ck8.0 source tree should be able to be combined with Tcl7.4, 7.5, 7.6, and 8.0. Older version of Ck (which use Tcl7.4 or Tcl7.5) are in use for several years on HP-UX, AIX, and DEC Unix.

Active Calendar is PHP Class, that generates calendars (month or year view) as a HTML Table (XHTML-Valid). Active Calendars source code is free.
You can modify or pass it on under the conditions of the GNU Lesser General Public License, published by the Free Software Foundation.
The calendars created by this class:
can be static (without any links)
can optionally have navigation controls
can optionally have a date picker control
can optionally have linkable days (url or javascript)
can optionally have event days with event links and own layout
can optionally have event content with links and own layout
support different GMT zones for the current date calculation
support month and day names, depending on your language
can be configured using CSS
do not require Javascript to be displayed or navigated (server side generation)
can be generated with just 2-3 lines of code
Active Calendar is based on the PHP native date functions (default) and supports optionally the ADOdb Date Library. Supported dates (on systems using a 32-bit signed integer Unix time_t):
Using PHP native date functions: 1902 - 2037 (UNIX) and 1971 - 2037 (Windows)
Using ADOdb Date Library: 100 - 3000 and later [ limited by the computation time of adodb_mktime() ] on both UNIX and Windows. To use the ADOdb Date Library just include it in your scripts. The Active Calendar class will use the library functions automatically.
Enhancements:
- An activeCalendarWeek subclass was added.
- The class can generate week calendars (one or multiple rows) according to the date or the week number of the year passed to the class using two public methods, showWeeks() and showWeeksByID().
- The structure of the download package was updated and an example was added for demonstrating how the Active Calendar can be used as a popup date selector in a form.

Active port forwarder is a software tool for secure port forwarding. Active port forwarder uses SSL to increase security of communication between a server and a client. Originally, it was developed to forward data point to point.
However, the need for bypassing firewalls in order to connect to internally located computers influenced the further development of the project.
AF is dedicated for people, who dont have an external ip number and want to make some services available across the net.
Moreover, zlib is used to compress the transferred data.
Using one, permanent data/control channel with flow control / packet buffering provides good performance and reasonably small latency.
Running afserver does not require root priviledges, nor does it use threads or other processes.
Enhancements:
- The bug in the ip_listen function (visible on the systems without IPv6 support) has been fixed.

Perlbug::Object is a object handler for Perlbug database.

Handles Perlbug database objects, typically bug, group, message, patch, note, test, user, and severity, status etc....

Methods included to recognise objects by their id or by their also unique name.

SYNOPSIS

my $o_obj = Perlbug::Object->new(%init); # see L

$o_obj = $o_obj->read($oid); # data

my $name = $o_obj->data(name); # Bug

# ALL bugids (optionally) constrained by sql where clause
my @ids = $o_obj->ids($where); # where

# Relation ids
my @patchids = $o_obj->rel_ids(patch); # relids

print = $o_obj->format(h);

CBL ActiveRecord project is an O/R mapping library for PHP5.x. Active Record is an object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.
Using this library, it becomes very easy to access the database.
- Development Status: Beta
- Intended Audience: Developers
- License: GNU Lesser General Public License (LGPL2.1orlater)
- Programming Language: PHP5, PHP5.1
- Translations: English, Japanese

Bio::Root::Object is a core Perl 5 object.

SYNOPSIS

# Use this module as the root of your inheritance tree.
Object Creation
require Bio::Root::Object;

$dad = new Bio::Root::Object();
$son = new Bio::Root::Object(-name => Junior,
-parent => $dad,
-make => full);
See the new() method for a complete description of parameters. See also the USAGE section .

Bio::Root::Object attempts to encapsulate the "core" Perl5 object: What are the key data and behaviors ALL (or at least most) Perl5 objects should have?
Rationale

Use of Bio::Root::Object.pm within the Bioperl framework facilitates operational consistency across the different modules defined within the Bio:: namespace. Not all objects need to derive from Bio::Root::Object.pm. However, when generating lots of different types of potentially complex objects which should all conform to a set of basic expectations, this module may be handy.

At the very least, this module saves you from re-writing the new() method for each module you develop. It also permits consistent and robust handling of -tag => value method arguments via the Bio::Root::RootI::_rearrange() method and provides a object-oriented way handle exceptions and warnings via the Bio::Root::Root::throw() and Bio::Root::Root::warn() methods.

See the APPENDIX section for some other handy methods.

Fault-Tolerant Objects

A major motivation for this module was to promote the creation of robust, fault-tolerant Perl5 objects. The Bio::Root::Root::throw() method relies on Perls built-in eval{}/die exception mechanism to generate fatal exceptions. The data comprising an exception is managed by the Bio::Root::Err.pm module, which essentially allows the data thrown by a die() event to be wrapped into an object that can be easily examined and possibly re-thrown.

The intent here is three-fold:

1 Detailed error reporting.
Allow objects to report detailed information about the error condition (who, what, where, why, how).
2 Handle complex errors in objects.
The goal is to make it relatively painless to detect and handle the wide variety of errors possible with a complex Perl object. Perls error handling mechanism is a might clunky when it comes to handling complex errors within complex objects, but it is improving.
3 Efficient & easy exception handling.
To enable robust exception handling without incurring a significant performance penalty in the resulting code. Ideally, exception handling code should be transparent to the cpu until and unless an exception arises.

These goals may at times be at odds and we are not claiming to have achieved the perfect balance. Ultimately, we want self- sufficient object-oriented systems able to deal with their own errors. This area should improve as the module, and Perl, evolve. One possible modification might be to utilize Graham Barrs Error.pm module or Torsten Ekedahls Experimental::Exception.pm module (see "Other Exception Modules").

Technologies such as these may eventually be incorporated into future releases of Perl. The exception handling used by Bio::Root::Object.pm can be expected to change as Perls exception handling mechanism evolves.

TERMINOLOGY NOTE: In this discussion and elsewhere in this module, the terms "Exception" and "Error" are used interchangeably to mean "something unexpected occurred" either as a result of incorrect user input or faulty internal processing.