Free object system software for linux

All System Info is a system info SuperKaramba theme. Simple english version...
It shows:
- System Info
- CPU usage
- Network Usage
- Memory Load
- HDD usage

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.

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.

Object::InsideOut is a comprehensive inside-out object support module.

SYNOPSIS

package My::Class; {
use Object::InsideOut;

# Numeric field
# With combined get+set accessor
my @data
:Field
:Type(numeric)
:Accessor(data);

# Takes INPUT (or input, etc.) as a mandatory parameter to ->new()
my %init_args :InitArgs = (
INPUT => {
Regex => qr/^input$/i,
Mandatory => 1,
Type => numeriC,
},
);

# Handle class-specific args as part of ->new()
sub init :Init
{
my ($self, $args) = @_;

# Put input parameter into data field
$self->set(@data, $args->{INPUT});
}
}

package My::Class::Sub; {
use Object::InsideOut qw(My::Class);

# List field
# With standard get_X and set_X accessors
# Takes INFO as an optional list parameter to ->new()
# Value automatically added to @info array
# Defaults to [ empty ]
my @info
:Field
:Type(list)
:Standard(info)
:Arg(Name => INFO, Default => empty);
}

package Foo; {
use Object::InsideOut;

# Field containing My::Class objects
# With combined accessor
# Plus automatic parameter processing on object creation
my @foo
:Field
:Type(My::Class)
:All(foo);
}

package main;

my $obj = My::Class::Sub->new(Input => 69);
my $info = $obj->get_info(); # [ empty ]
my $data = $obj->data(); # 69
$obj->data(42);
$data = $obj->data(); # 42

$obj = My::Class::Sub->new(INFO => help, INPUT => 86);
$data = $obj->data(); # 86
$info = $obj->get_info(); # [ help ]
$obj->set_info(qw(foo bar baz));
$info = $obj->get_info(); # [ foo, bar, baz ]

my $foo_obj = Foo->new(foo => $obj);
$foo_obj->foo()->data(); # 86

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.

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);