Free gym class heroes software for linux

Class::Interfaces is a Per module for defining interface classes inline.

SYNOPSIS

# define some simple interfaces
use Class::Interfaces (
Serializable => [ pack, unpack ],
Printable => [ toString ],
Iterable => [ iterator ],
Iterator => [ hasNext, next ]
);

# or some more complex ones ...

# interface can also inherit from
# other interfaces using this form
use Class::Interfaces (
BiDirectionalIterator => {
isa => Iterator,
methods => [ hasPrev, prev ]
},
ResetableIterator => {
isa => Iterator,
methods => [ reset ]
},
# we even support multiple inheritance
ResetableBiDirectionalIterator => {
isa => [ ResetableIterator, BiDirectionalIterator ]
}
);

# it is also possible to create an
# empty interface, sometimes called
# a marker interface
use Class::Interfaces (
JustAMarker => undef
);

This module provides a simple means to define abstract class interfaces, which can be used to program using the concepts of interface polymorphism.

Heroes project is a Nibbles-like game, just better.
Heroes is similar to the "Tron" and "Nibbles" games of yore, but includes many graphical improvements and new game features.
In it, you must maneuver a small vehicle around a world and collect powerups while avoiding obstacles, your opponents trails, and even your own trail.
There are five game modes available. Quest is the classical Nibbles, in Death Match you start with very long tails and must kill your opponents, in Killem All you must run over lemmings moving on the ground, in Time Cash or Color modes you must collect money or pyramids of color. Heroes features 12 original sound tracks, 94 levels (in 10 different tile sets) plus a level editor.
Heroes source code (distributed under the GNU General Public Licence version 2) originates from an original MS-DOS game but has been heavily modified to enhance the portability. Some new features have been added and MS-DOS support has been lost by the meantime. The original MS-DOS version can still be found on the Internet but is unmaintained and should be considered obsolete.
The current development concentrates on cleaning the code and porting the game to the various operating systems available. Our objective is to release the version 1.0 as a clean and portable base that would allow significant additions such as network support or programmable vehicles.
Enhancements:
- Support for the heroes-hq-sound-tracks package.
Bug fixes:
- soundconf: failed to override aliases.
- Heroes GGI driver failed to report an error if no two-frame mode was available.
- Various code nits.

Class::Meta::Express is a Perl module for concise, expressive creation of Class::Meta classes.

Synopsis

package My::Contact;
use Class::Meta::Express;

class {
meta contact => ( default_type => string );
has name;
has contact => ( required => 1 );
}

This module provides an interface to concisely yet expressively create classes with Class::Meta. Although I am of course fond of Class::Meta, Ive never been overly thrilled with its interface for creating classes:

package My::Thingy;
use Class::Meta;

BEGIN {
# Create a Class::Meta object for this class.
my $cm = Class::Meta->new( key => thingy );

# Add a constructor.
$cm->add_constructor( name => new );

# Add a couple of attributes with generated accessors.
$cm->add_attribute(
name => id,
is => integer,
required => 1,
);

$cm->add_attribute(
name => name,
is => string,
required => 1,
);

$cm->add_attribute(
name => age,
is => integer,
);

# Add a custom method.
$cm->add_method(
name => chk_pass,
code => sub { return code },
);
$cm->build;
}

This example is relatively simple; it can get a lot more verbose. But even still, all of the method calls were annoying. I mean, whoever thought of using an object oriented interface for declaring a class? (Oh yeah: I did.) I wasnt alone in wanting a more declarative interface; Curtis Poe, with my blessing, created Class::Meta::Declare, which would use this syntax to create the same class:

package My::Thingy;
use Class::Meta::Declare :all;

Class::Meta::Declare->new(
# Create a Class::Meta object for this class.
meta => [
key => thingy,
],
# Add a constructor.
constructors => [
new => { }
],
# Add a couple of attributes with generated accessors.
attributes => [
id => {
type => $TYPE_INTEGER,
required => 1,
},
name => {
required => 1,
type => $TYPE_STRING,
},
age => { type => $TYPE_INTEGER, },
],
# Add a custom method.
methods => [
chk_pass => {
code => sub { return code },
}
]
);

This approach has the advantage of being a bit more concise, and it is declarative, but I find all of the indentation levels annoying; its hard for me to figure out where I am, especially if I have to define a lot of attributes. And finally, everything is a string with this syntax, except for those ugly read-only scalars such as $TYPE_INTEGER. So I cant easily tell where one attribute ends and the next one starts. Bleh.

Class::HPLOO is an easier way to declare classes on Perl, based in the popular class {...} style and ePod.

USAGE

use Class::HPLOO ;

class Foo extends Bar , Baz {

use LWP::Simple qw(get) ; ## import the method get() to this package.

attr ( array foo_list , int age , string name , foo ) ## define attributes.

vars ($GLOBAL_VAR) ; ## same as: use vars qw($GLOBAL_VAR);

my ($local_var) ;

## constructor/initializer:
sub Foo {
$this->{attr} = $_[0] ;
}

## methods with input variables declared:
sub get_pages ($base , @pages , %options) {
my @htmls ;

if ( $options{proxy} ) { ... }

foreach my $pages_i ( @pages ) {
my $url = "$base/$pages_i" ;
my $html = get($url) ;
push(@htmls , $html) ;
$this->cache($url , $html) ;
}

return @htmls ;
}

## methos like a normal Perl sub:
sub cache {
my ( $url , $html ) = @_ ;
$this->{CACHE}{$url} = $html ;
}

sub attributes_example {
$this->set_foo_list(qw(a b c d e f)) ;
my @l = $this->get_foo_list ;

$this->set_age(30) ;
$this->set_name("Joe") ;
$this->set_foo( time() ) ;
print "NAME: ". $this->get_name ."n" ;
print "AGE: ". $this->get_age ."n" ;
print "FOO: ". $this->get_foo ."n" ;
}

}

## Example of use of the class:

package main ;

my $foo = new Foo(123) ;
$foo->get_pages(http://www.perlmonks.com/, [/index.pl,/foo] , {proxy => localhost:8080}) ;

Class::Observable is a Perl module that allows other classes and objects to respond to events in yours.

SYNOPSIS

# Define an observable class

package My::Object;

use base qw( Class::Observable );

# Tell all classes/objects observing this object that a state-change
# has occurred

sub create {
my ( $self ) = @_;
eval { $self->_perform_create() };
if ( $@ ) {
My::Exception->throw( "Error saving: $@" );
}
$self->notify_observers();
}

# Same thing, except make the type of change explicit and pass
# arguments.

sub edit {
my ( $self ) = @_;
my %old_values = $self->extract_values;
eval { $self->_perform_edit() };
if ( $@ ) {
My::Exception->throw( "Error saving: $@" );
}
$self->notify_observers( edit, old_values => %old_values );
}

# Define an observer

package My::Observer;

sub update {
my ( $class, $object, $action ) = @_;
unless ( $action ) {
warn "Cannot operation on [", $object->id, "] without action";
return;
}
$class->_on_save( $object ) if ( $action eq save );
$class->_on_update( $object ) if ( $action eq update );
}

# Register the observer class with all instances of the observable
# class

My::Object->add_observer( My::Observer );

# Register the observer class with a single instance of the
# observable class

my $object = My::Object->new( foo );
$object->add_observer( My::Observer );

# Register an observer object the same way

my $observer = My::Observer->new( bar );
My::Object->add_observer( $observer );
my $object = My::Object->new( foo );
$object->add_observer( $observer );

# Register an observer using a subroutine

sub catch_observation { ... }

My::Object->add_observer( &catch_observation );
my $object = My::Object->new( foo );
$object->add_observer( &catch_observation );

# Define the observable class as a parent and allow the observers to
# be used by the child

package My::Parent;

use strict;
use base qw( Class::Observable );

sub prepare_for_bed {
my ( $self ) = @_;
$self->notify_observers( prepare_for_bed );
}

sub brush_teeth {
my ( $self ) = @_;
$self->_brush_teeth( time => 45 );
$self->_floss_teeth( time => 30 );
$self->_gargle( time => 30 );
}

sub wash_face { ... }


package My::Child;

use strict;
use base qw( My::Parent );

sub brush_teeth {
my ( $self ) = @_;
$self->_wet_toothbrush();
}

sub wash_face { return }

# Create a class-based observer

package My::ParentRules;

sub update {
my ( $item, $action ) = @_;
if ( $action eq prepare_for_bed ) {
$item->brush_teeth;
$item->wash_face;
}
}

My::Parent->add_observer( __PACKAGE__ );

$parent->prepare_for_bed # brush, floss, gargle, and wash face
$child->prepare_for_bed # pretend to brush, pretend to wash face

Dynamic Probe Class Library (DPCL) is an object-based C++ class library that provides the necessary infrastructure to allow tool developers and sophisticated tool users to build parallel and serial tools through technology called dynamic instrumentation.
Dynamic Probe Class Library takes the basic components needed by tool developers and encapsulates them into C++ classes. Each of these classes provide the member functions necessary to interact and dynamically instrument a running application with software patches called probes.
Dynamic instrumentation provides the flexibility for tools to insert probes into applications as the application is running and only where it is needed.
Enhancements:
- This version is a minor update to DPCL that fixes a couple problems that have been reported since the v3.4.2 release

Class::Adapter is a Perl implementation of the "Adapter" Design Pattern.

The Class::Adapter class is intended as an abstract base class for creating any sort of class or object that follows the Adapter pattern.

What is an Adapter?

The term Adapter refers to a "Design Pattern" of the same name, from the famous "Gang of Four" book "Design Patterns". Although their original implementation was designed for Java and similar single-inheritance strictly-typed langauge, the situation for which it applies is still valid.

An Adapter in this Perl sense of the term is when a class is created to achieve by composition (objects containing other object) something that cant be achieved by inheritance (sub-classing).

This is similar to the Decorator pattern, but is intended to be applied on a class-by-class basis, as opposed to being able to be applied one object at a time, as is the case with the Decorator pattern.

The Class::Adapter object holds a parent object that it "wraps", and when a method is called on the Class::Adapter, it manually calls the same (or different) method with the same (or different) parameters on the parent object contained within it.

Instead of these custom methods being hooked in on an object-by-object basis, they are defined at the class level.

Basically, a Class::Adapter is one of your fall-back positions when Perls inheritance model fails you, or is no longer good enough, and you need to do something twisty in order to make several APIs play nicely with each other.

What can I do with the actual Class::Adapter class

Well... nothing really. It exist to provide some extremely low level fundamental methods, and to provide a common base for inheritance of Adapter classes.
The base Class::Adapter class doesnt even implement a way to push method calls through to the underlying object, since the way in which that happens is the bit that changes from case to case.

To actually DO something, you probably want to go take a look at Class::Adapter::Builder, which makes the creation of Adapter classes relatively quick and easy.

PHP HTML Graph Class is a class for drawing vertical bar graphs using only HTML and CSS. Simple and grouped bars can be created. You can change everything regarding the looks as the output is template-driven.
On the fly, you can change the size of graph, the color of all or individual bars, add labels, a title, and footnotes, or customize the CSS style of all elements. The width and height of bars can be specified in pixels or percentages. The code is heavily documented.
Enhancements:
- In some PHP versions, there were some issues regarding passing variables by reference.
- The class would produce no output (nor errors) in PHP versions lower than 5 due to the different implementations of PHPs get_class() function in these versions.