Free implementation plan template software for linux

Suffix tree implementation library is a C library, an implementation of the suffix trees algorithm to store/retrieve key/data pairs.
The main advantages are a linear indexing time, little memory usage, and very fast retrieving.
It has been developped on FreeBSD/gcc but should be fairly portable.
The source code "testsfx.c" show an example of how to use the library both for inserting, retrieving, and deleting data. There arent many functions and comments should be enough to give you an idea of how to use the library. (read the header of the source file)
You should edit sfxdisk.h to suit your needs: you can change the alphabet size and the offset type. It should be OK to use "long long" 64 bits ints instead of long, in fact I tested it succesfully but havent gone to the point of filling more than 2 GB of data (needless to say you need a 64 bits filesystem).
Two "tools" come with the library (new with version 1.2): dumpsfx and loadsfx. dumpsfx is used to dump the database: dumpsfx [-s separator] if you want to output the result as readable text or dumpsfx < file.sfx > -h to output it for reloading with loadsfx.
dumpsfx outputs on stdout and loadsfx reads from stdin. loadsfx < suffix tree file to create > < dumped_file
Enhancements:
- removed an useless offset incrementation in STwritenode

Class::MakeMethods::Template package contains extensible code templates.

SYNOPSIS

package MyObject;
use Class::MakeMethods::Template::Hash (
new => new,
string => foo,
number => bar,
);

my $obj = MyObject->new( foo => "Foozle", bar => 23 );
print $obj->foo();
$obj->bar(42);

MOTIVATION

If you compare the source code of some of the closure-generating methods provided by other subclasses of Class::MakeMethods, such as the hash accessors provided by the various Standard::* subclasses, you will notice a fair amount of duplication. This module provides a way of assembling common pieces of code to facilitate support the maintenance of much larger libraries of generated methods.

This module extends the Class::MakeMethods framework by providing an abstract superclass for extensible code-templating method generators.
Common types of methods are generalized into template definitions. For example, Template::Generics new provides a template for methods that create object instances, while Template::Generics scalar is a template for methods that allow you to get and set individual scalar values.

Thse definitions are then re-used and modified by various template subclasses. For example, the Template::Hash subclass supports blessed-hash objects, while the Template::Global subclass supports shared data; each of them includes an appropriate version of the scalar accessor template for those object types.

Each template defines one or more behaviors, individual methods which can be installed in a calling package, and interfaces, which select from those behaviours and indicate the names to install the methods under.

Each individual meta-method defined by a calling package requires a method name, and may optionally include other key-value parameters, which can control the operation of some meta-methods.

Dicop::Item::Template is an object defining Dicop::Item subclasses.

SYNOPSIS

use Dicop::Request::Template

push @templates, Dicop::Item::Template->new (
class => Dicop::Item::Subclass,
fields => "name => { maxlen => 128, def => some name }",
);

Piffle::Template is a Perlish templating language.

SYNOPSIS

use Piffle::Template;
use Piffle::Template qw{template_to_perl expand_template};

# OO syntax, with output stored and returned:
print Piffle::Template->expand(source_file => foo/fish.xml,
include_path => [foo/inc,foo]);

# Immediate: OO syntax: output goes directly to STDOUT:
Piffle::Template->expand(source_file => foo/fish.xml,
output_file => *STDOUT);

# Procedural syntax, data from a string
$string =
< ?perl } ? >
< ?include std_disclaimer.txt? >
__END__
expand_template(source => $string,
output_file => *FILE);

This is a simple Perl-embedding syntax for template code which is geared towards allowing authors to validate their templates directly against schemas or DTDs. The embedded language is Perl itself, which allows great flexibility at the expense of having to be disciplined about the barrier between template code and module code.

In operation, the source template is transformed to an in-memory Perl script which is then run using Perls eval operator. Errors can be redirected to files or subroutines, and the output can be either caught in a variable or written to a file or open filehandle.

Procinfo NG is a ground-up rewrite of the procinfo program. Procinfo NGs goal is to make the code more readable (and reusable) and to restore broken functionality of the original program.
The original program was written for Linux 1.0, and updated through 2.2. This version is for 2.6.
Enhancements:
- Updates were made to match what some Linux distributions have done to procinfo-18.
- Support for MSI and XEN interrupts were added.
- Some non-x86 architectures are handled.
- Assorted bugs and 80-character console nonsense were fixed.

HCKit::Template is a Perl module with a template system for HTML construction.

This module constructs an HTML page from a template. The conversion proceeds with the help of rewrite rules and data sources. Rewrite rules can be specified in the template file itself, or in the Perl script. Data sources can be XML files, or dynamically constructed in the Perl script.

HTML::Template::JIT is a just-in-time compiler for HTML::Template. Templates are compiled into native machine code using Inline::C.
When using HTML::Template::JIT, the compiled code is stored to disk and reused on subsequent calls. HTML::Template::JIT is up to 8 times as fast as HTML::Template using caching.
Enhancements:
- Fixed param() to allow for blessed hash-refs. [Alex Kapranoff]
- Fixed url-escaping to work with UTF-8 characters. [Alex Kapranoff]
- Added support for JS escaping. [Alex Kapranoff]
- Fixed a compatibility problem with HTML::Template v2.8, which is now a prerequisite.