Free multiple inheritance software for linux

Tk::PerlInheritanceTree is a Perl module that displays a graphical representation of the inheritance tree for a given class-name.

SYNOPSIS

require Tk::PerlInheritanceTree;
...
my $inheritance_tree = $main_window->PerlInheritanceTree()->pack;

$inheritance_tree->classname(Tk::MainWindow);

Tk::PerlInheritanceTree displays a graphical representation of the inheritance tree for a given class(package)-name. The nodes representing classnames have mouseclick bindings to open a Tk::PerlMethodList - widget. Tk::PerlInheritanceTree is a Tk::Frame-derived widget.

PerlInheritanceTree.pm can be run as stand-alone application.

METHODS

Tk::PerlInheritanceTree supports the following methods:

classname(A::Classname)

Set the Classname-Entry to A::Classname and show_classtree.

show_classtree()

Display a tree for the given classname

OPTIONS

Tk::PerlInheritanceTree supports the following options:

-classname

configure(-classname=>A::Classname) same as method classname()

-gridsize

configure(-gridsize=>$size) Set the distance between nodes to $size pixels. Defaults to 100.

-multiple_methodlists

configure(-multiple_methodlists=>bool) Allows multiple instances of PerlMethodList to be opened if set to a true value. Defaults to 0.

XML::Compile::Schema::Translate is a Perl module to create an XML data parser.

INHERITANCE

XML::Compile::Schema::Translate
is an Exporter

SYNOPSIS

# for internal use only!

This module converts a schema type definition into a code reference which can be used to interpret a schema. The sole public function in this package is compile_tree(), and is called by XML::Compile::Schema::compile(), which does a lot of set-ups. Please do not try to use this package directly!

The code in this package interprets schemas; it understands, for instance, how complexType definitions work. Then, when the schema syntax is decoded, it will knot the pieces together into one CODE reference which can be used in the main user program.

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.

Simple Python Fixed-Point Module or SPFPM in short, is a Python module which provides basic facilities for manipulating (binary) fixed-point numbers.
The number of fractional binary digits is tunable, allowing near-arbitrary precision arithmetic. Arithmetic and mathematical functions such as sqrt, exp, log, sin, and cos are available
Enhancements:
- Inverse sin/cosine routines were improved. Inheritance-based typing was replaced by duck-typing.

Qu is a powerful full-featured object oriented programming language. It is an Open Source software. The Qu Programming Language is absolutely free (as in free lunch) and distributed under the GNU General Public License (GPL).
Qu is inspired by other languages. Most noticeably Perl, Python, Ruby and C. It mostly resembles Python except that the syntax is more flexible, the internals are simpler, and Qu allows you to use either indentation or non-indentation style.
Qu has a clean syntax designed to promote readability. There is no need for semi-colons and commas to separate items except in rare cases when the end of an expression is not obvious.
Qu is a procedural language. A program consist of statements and expressions evaluated in the order they appear.
Qu is a strong semi-dynamic (optional-static) typing language. Adding a number to a string will throw an exception. A variable can hold anything or you can attach a validator to it. Validators can be as simple as a class, a constant object (Array, Range, Struct, etc.) or even a validator function.
Arrays, dictionaries, and sets can be constrained to hold only a specific "type" of data as well.
Everything in Qu are objects, including numbers, strings, etc. The number 123, for example, is actually an instance of the builtin Int class. Classes are instances of the builtin Class class, etc. But this does not mean that you must write your programs in an object oriented manner. That is entirely up to you.
Documentation can be embedded in the source code. The compiler will skip them. The documentation builder will extract them. The builder is included as part of the standard distribution.
In fact, when you install Qu or Qu modules, the documentations are automatically built for you.
Qu is entirely written in C. Readable documentations are embedded in the C sources directly.
Writing C modules for Qu is as easy as it can get!
Main features:
- fast
- clean syntax
- strong semi-dynamic typing
- module management
- multithread
- deadlock detection
- label loops, break, continue, redo
- loop, while, for, atomic, do
- fast exceptions
- try, catch, else, finally
- nested function
- lexical closure
- accummulator
- generator
- coroutine
- type validator
- run once function
- full and safe eval
- buffered printing
- auto self
- private, public and static attributes
- read/write & read-only attributes
- class property and methods
- dynamic attribute access
- single inheritance with mixins
- multiple constructors
- super class attribute access
- finalizers
- multiple assignment
- variable and default arguments
- argument flattening
- uniform attribute access
- complex number
- big integer
- mark & sweep garbage collector

Mail::Message::Convert::TextAutoformat is a Perl module that can reformat plain text messages.

INHERITANCE

Mail::Message::Convert::TextAutoformat
is a Mail::Message::Convert
is a Mail::Reporter

SYNOPSIS

use Mail::Message::Convert::TextAutoformat;
my $af = Mail::Message::Convert::TextAutoformat->new;

my $beautified_body = $af->autoformatBody($body);

Play trics with plain text, for instance bodies with type text/plain using Damian Conways Text::Autoformat.