Free suffix tree software for linux

STX B+ Tree project is a set of C++ template classes implementing a B+ tree key/data container in main memory. The classes are designed as drop-in replacements of the STL containers set, map, multiset and multimap and follow their interfaces very closely. By packing multiple value pairs into each node of the tree the B+ tree reduces heap fragmentation and utilizes cache-line effects better than the standard red-black binary tree.
The tree algorithms are based on the implementation in Cormen, Leiserson and Rivests Introduction into Algorithms, Jan Janninks paper and other algorithm resources. The classes contain extensive assertion and verification mechanisms to ensure the implementations correctness by testing the tree invariants.
The main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments btree.h.
Special interest was put into performing a speed comparison test between the standard red-black tree and the new B+ tree implementation. The speed test results are interesting and show the B+ tree to be significantly faster.
Enhancements:
- This release introduces the demonstration program wxBTreeDemo.
- This program draws illustrations of the B+ trees constructed by the STX B+ Tree template classes.
- It allows the user to select different types of B+ tree instantiations: integer or string keys and different slot numbers.
- The user may insert and erase key/data pairs from the tree and run different search operations.
- The demo program uses the cross-platform wxWidgets toolkit and can be compiled on Linux, Windows, and Mac OS X.

Image Tree is a complete and versatile photo publishing system in less than 200 lines of code.

ImgTree is based only on three files:

index php : contains all the php and html code. Must be put, unmodified in every folder of the directory tree.
data.php : contains the specific settings of every folder
style.css : the css style sheet

Every folder of the folder tree must contain the three files. Clearly index.php and style.php should be simply linked:

imgtree/
|-- data.php
|-- index.php
|-- style.css
|-- Section-A
| |-- data.php
| |-- index.php -> ../index.php
| |-- style.css -> ../style.css
| |-- 01-thumb.jpg
| |-- 01.jpg
| |-- 02-thumb.jpg
| |-- 02.jpg
| `-- ...
`-- Section-B
|-- data.php
|-- index.php -> ../index.php
|-- style.css -> ../style.css
|-- 00.jpg
|-- Subsection-B1
| |-- data.php
| |-- index.php -> ../index.php
| `-- style.css -> ../style.css
| |-- cover.jpg
`-- Subsection-B2
|-- data.php
|-- index.php -> ../index.php
|-- style.css -> ../style.css
|-- 01-thumb.jpg
|-- 01.jpg
|-- 02-thumb.jpg
|-- 02.jpg
`-- ...

Every folder act as a section and the behaviour can be choose between:

index : Contains a list of links to every subfolder of the current folder. For every section an image and a description are shown.
thumb : Thumbnails page. Shows every image file of the folder. Thumbnail must be named "xxx-thumb.jpg" for the xxx.jpg file. Ex: 01-thumb.jpg -> 01.jpg ; tramonto-thumb.jpg -> tramonto.jpg ; ecc.
cover : Cover page. Shows an image, a text and an associated link

The file data.php contin the settings specific for every section:

$gallerystart : is the gallery start to generate the back-menu. The path must be relative to the starting folder of the site
$name : name used to link the current section in the menus
$title : page title
$description: description, used as subtitle and for brief description in index pages
$indeximage : image used in index pages to link this section
$type : type of the page (cover|thumb|index)
$imgtitle : associtive array of the images descriptions. Used only by "thumb" pages
$coverimage : image used by "cover" pages
$covertext : text used by "cover" pages
$coverlink= : link used by "cover" pages
$covertitle : title used by "cover" pages

NEEDS a web server (Apache or similar) with PHP support

libstree is a generic suffix tree implementation, written in C. libstree library can handle arbitrary data structures as elements of a string. Unlike most demo implementations, it is thus not limited to simple ASCII character strings.
Suffix tree generation in libstree is highly efficient and implemented using the algorithm by Ukkonen, which means that libstree builds suffix trees in time linear to the length of the strings (assuming that string element comparisons can be done in O(1)).
libstree can handle multiple strings per suffix tree, including dynamic insertion and removal of strings. It provides various means of obtaining information about nodes in the tree, such as depth-first and breadth-first iteration, leaves iteration, and bottom-up iteration.
libstree provides implementations of longest-common-substring and longest-repeated-substring algorithms, as examples of how to build complex algorithms using the suffix tree primitives.
Installation:
The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a `Makefile in each directory of the package.
It may also create one or more `.h files containing system-dependent definitions. Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, and a file `config.log containing compiler output (useful mainly for debugging `configure).
It can also use an optional file (typically called `config.cache and enabled with `--cache-file=config.cache or simply `-C) that saves the results of its tests to speed up reconfiguring. (Caching is disabled by default to prevent problems with accidental use of stale cache files.)
If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.
If you are using the cache, and at some point `config.cache contains results you dont want to keep, you may remove or edit it.
The file `configure.ac (or `configure.in) is used to create `configure by a program called `autoconf. You only need `configure.ac if you want to change it or regenerate `configure using a newer version of `autoconf.
The simplest way to compile this package is:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute
`configure itself.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Optionally, type `make check to run any self-tests that come with the package.
4. Type `make install to install the programs and any data files and documentation.
5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.
There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
Enhancements:
- LCS can now be run repeatedly on a single unmodified tree without problems.
- A memory leak in lst_stree_clear() has been fixed.

DBIx::OO::Tree is a Perl module to manipulate hierarchical data using the "nested sets" model.

SYNOPSYS

CREATE TABLE Categories (
id INTEGER UNSIGNED AUTO_INCREMENT PRIMARY KEY,
label VARCHAR(255),

-- these columns are required by DBIx::OO::Tree
parent INTEGER UNSIGNED,
lft INTEGER UNSIGNED NOT NULL,
rgt INTEGER UNSIGNED NOT NULL,
mvg TINYINT DEFAULT 0,

INDEX(lft),
INDEX(rgt),
INDEX(mvg),
INDEX(parent)
);

* * *

package Category;
use base DBIx::OO;
use DBIx::OO::Tree;

__PACKAGE__->table(Categories);
__PACKAGE__->columns(P => [ id ],
E => [ label, parent ]);

# note its not necessary to declare lft, rgt, mvg or parent. We
# declare parent simply because it might be useful, but
# DBIx::OO:Tree works with low-level SQL therefore it doesnt
# require that the DBIx::OO object has these fields.

# the code below creates the structure presented in [1]

my $electronics = Category->tree_append({ label => electronics });
my $tvs = $electronics->tree_append({ label => televisions });
my $tube = $tvs->tree_append({ label => tube });
my $plasma = $tvs->tree_append({ label => plasma });
my $lcd = $plasma->tree_insert_before({ label => lcd });
my $portable = $tvs->tree_insert_after({ label => portable electronics });
my $mp3 = $portable->tree_append({ label => mp3 players });
my $flash = $mp3->tree_append({ label => flash });
my $cds = $portable->tree_append({ label => cd players });
my $radios = Category->tree_append($portable->id,
{ label => 2 way radios });

# fetch and display a subtree

my $data = $electronics->tree_get_subtree({
fields => [qw( label lft rgt parent )]
});
my $levels = Category->tree_compute_levels($data);

foreach my $i (@$data) {
print x $levels->{$i->{id}}, $i->{label}, "n";
}

## or, create DBIx::OO objects from returned data:

my $array = Category->init_from_data($data);
print join("n", (map { x $levels->{$_->id} . $_->label } @$array));

# display path info

my $data = $flash->tree_get_path;
print join("n", (map { $_->{label} } @$data));

# move nodes around

$mp3->tree_reparent($lcd->id);
$tvs->tree_reparent($portable->id);
$cds->tree_reparent(undef);

$plasma->tree_move_before($tube->id);
$portable->tree_move_before($electronics->id);

# delete nodes

$lcd->tree_delete;

This module is a complement to DBIx::OO to facilitate storing trees in database using the "nested sets model", presented in [1]. Its main ambition is to be extremely fast at retrieving data (sacrificing for this the performance of UPDATE-s, INSERT-s or DELETE-s). Currently this module requires you to have these columns in the table:

- id: primary key (integer)
- parent: integer, references the parent node (NULL for root nodes)
- lft, rgt: store the node position
- mvg: used only when moving nodes

"parent" and "mvg" are not esentially required by the nested sets model as presented in [1], but they are necessary for this module to work. In particular, "mvg" is only required by functions that move nodes, such as tree_reparent(). If you dont want to move nodes around you can omit "mvg".

Retrieval functions should be very fast (one SQL executed). To further promote speed, they dont return DBIx::OO blessed objects, but an array of hashes instead. Its easy to create DBIx::OO objects from these, if required, by calling DBIx::OO->init_from_data() (see DBIx::OO for more information).

Insert/delete/move functions, however, need to ensure the tree integrity. Heres what happens currently:

- tree_append, tree_insert_before, tree_insert_after -- these execute
one SELECT and two UPDATE-s (that potentially could affect a lot of
rows).

- tree_delete: execute one SELECT, one DELETE and two UPDATE-s.

- tree_reparent -- executes 2 SELECT-s and 7 UPDATE-s. I know, this
sounds horrible--if you have better ideas Id love to hear them.

Ports Tree Explorer (PTE) is a small tool that allows you to navigate through your /usr/ports tree, showing you information about a selected port, tree view, software categories (/usr/ports main dirs) and finally allows you to install a selected port using childs for the installation.
PTE Allows you to monitor background installs and allow you to perform certain operations related to your software ports tree, with a plain and simple GUI requires almost minimum shell interaction.
Newer versions will include CVS updates off the ports, managing/modifying a specific port, see available FLAVORS and finally specify compilation options for this port. Ports Tree Explorer is written in perl/tk and its working (tested) on Open BSD. PTE is free and improvements, adjustments etc. are more than welcomed.
PTE aims to be an easy to use tool. Plain and simple as possible, functional for new users of /usr/ports tree along with experienced users that get bored often.
The scope of this project is to provide an easy way to use/maintain and install programs from your ports tree.
At the current stage, we aim to be usable and all the required functions be implemented and work.
After this goes to a stable release, security enhancements and extra functionality will be added.
Main features:
- Ports Category separation
- Ports Program separation
- Description of Port
- Install selected port
- History of executed commands (Installations)
Enhancements:
- Kill a background install.
- Changed the state of background install from Started to Finished (when the install is actually finished)
- Save history to file.
- Direct output from the fork to the output window.
- Support for other ports, like NetBSD, Free BSD ports.

mod_domaintree is a hostname to filesystem mapper for Apache2. It maps host names like www.example.com to a filesystem tree like $prefix/com/example/www/$suffix.
mod_domaintree module can optionally strip the www prefix of host names.
Enhancements:
- The suexec hook and DomainTreeSuexec directory configuration directive were added.
- "make clean" was fixed.

dtRdr::GUI::Wx::Tree::Base is a base class for sidebar trees.

SYNOPSIS

init

$tree->init($frame);

select_item

Select the tree item for a given $id.

$tree->select_item($id)

The id is probably the id of whatever your widget associated with each tree item.

Convenience

id_or_id

Checks whether $id is a scalar or an object which can(id) and return the id.

$id = $self->id_or_id($id);