Free class diagrams software for linux

Ghost Diagrams is a project that takes sets of tiles and tries to find patterns into which they may be formed. The patterns it finds when given randomly chosen tiles are often surprising.

It turns out that tiling patterns are a form of computation of equal power to Turing machines, lambda calculus, and cellular automata. For example, here is a tileset implementing "Rule 110", a cellular automaton known to be capable of universal computation.

Considerations similar to the halting problem and Godels theorem apply. There is no upper limit to their capacity to surprise us. Furthermore, tiles have an intuitive quality that other forms of computation lack. You can see how they fit together.

An organism is more than the sum of its organs. When the organs are fitted together, the organism becomes something more. This surprising something more we call "spirit" or "ghost". Ghost Diagrams finds the ghosts implicit in simple sets of tiles.

Class::DBI::FormTools is a Perl module to build forms with multiple interconnected objects.

SYNOPSIS

package MyApp::Film;
use base Class::DBI::FormTools;
Mason example
< %init >
my $o = Film->retrieve(42);
< /%init >
< form >
< input name="< % $o- >form_fieldname(title) % >" type="text" value="< % $o- >title % >" / >
< /form >

On the receiving end:

my @objects = Class::DBI::FormTools->formdata_to_objects($quesrstring);

This is alpha software - Highly experimental - Everything might change!

INTERFACE

form_field

FIXME

form_fieldname

FIXME

formdata_to_objects

FIXME

Class::Generate is a Perl module that can generate Perl class hierarchies.

SYNOPSIS

use Class::Generate qw(class subclass delete_class);

# Declare class Class_Name, with the following types of members:
class
Class_Name => [
s => $, # scalar
a => @, # array
h => %, # hash
c => Class, # Class
c_a => @Class, # array of Class
c_h => %Class, # hash of Class
&m => body, # method
];

# Allocate an instance of class_name, with members initialized to the
# given values (pass arrays and hashes using references).
$obj = Class_Name->new ( s => scalar,
a => [ values ],
h => { key1 => v1, ... },
c => Class->new,
c_a => [ Class->new, ... ],
c_h => [ key1 => Class->new, ... ] );

# Scalar type accessor:
$obj->s($value); # Assign $value to member s.
$member_value = $obj->s; # Access members value.

# (Class) Array type accessor:
$obj->a([value1, value2, ...]); # Assign whole array to member.
$obj->a(2, $value); # Assign $value to array member 2.
$obj->add_a($value); # Append $value to end of array.
@a = $obj->a; # Access whole array.
$ary_member_value = $obj->a(2); # Access array member 2.
$s = $obj->a_size; # Return size of array.
$value = $obj->last_a; # Return last element of array.

# (Class) Hash type accessor:
$obj->h({ k_1=>v1, ..., k_n=>v_n }) # Assign whole hash to member.
$obj->h($key, $value); # Assign $value to hash member $key.
%hash = $obj->h; # Access whole hash.
$hash_member_value = $obj->h($key); # Access hash member value $key.
$obj->delete_h($key); # Delete slot occupied by $key.
@keys = $obj->h_keys; # Access keys of member h.
@values = $obj->h_values; # Access values of member h.

$another = $obj->copy; # Copy an object.
if ( $obj->equals($another) ) { ... } # Test equality.

subclass s => [ ], -parent => class_name;

The Class::Generate package exports functions that take as arguments a class specification and create from these specifications a Perl 5 class. The specification language allows many object-oriented constructs: typed members, inheritance, private members, required members, default values, object methods, class methods, class variables, and more.

CPAN contains similar packages. Why another? Because object-oriented programming, especially in a dynamic language like Perl, is a complicated endeavor. I wanted a package that would work very hard to catch the errors you (well, I anyway) commonly make. I wanted a package that could help me enforce the contract of object-oriented programming. I also wanted it to get out of my way when I asked.

Class::DBI::DataMigration::Mapping is an abstract parent class for objects that map a single column in a single row from the source database to the target database.

Synopsis

use Class::DBI::DataMigration::Mapping;

# ... Later, when building $mappings hashref for use by a
# Class::DBI::DataMigration::Mapper (which see for synopsis --
# in this example, assume an appropriate @source_keys):

foreach my $source_key (@source_keys) {
$mappings{$source_key} = new Class::DBI::DataMigration::Mapping;
}

# ... Now we can assign $mappings to our Mapper ...

Class::DBI::DataMigration::Mapping objects are used by Class::DBI::DataMigration::Mapper objects to retrieve the values for particular keys into source database objects; these will in turn be stored under particular keys into newly-created target database objects.