Dependency of nagios-plugins-nwc-health-8.0-1.1.src.rpm

Name: perl-Tree-DAG_Node

Project: openSUSE_13.2

Repository: oss

Title: An N-ary tree

Description:
This class encapsulates/makes/manipulates objects that represent nodes in a
tree structure. The tree structure is not an object itself, but is emergent
from the linkages you create between nodes. This class provides the methods
for making linkages that can be used to build up a tree, while preventing
you from ever making any kinds of linkages which are not allowed in a tree
(such as having a node be its own mother or ancestor, or having a node have
two mothers).

This is what I mean by a "tree structure", a bit redundantly stated:

* o A tree is a special case of an acyclic directed graph

* o A tree is a network of nodes where there's exactly one root node

Also, the only primary relationship between nodes is the mother-daughter
relationship.

* o No node can be its own mother, or its mother's mother, etc

* o Each node in the tree has exactly one parent

Except for the root of course, which is parentless.

* o Each node can have any number (0 .. N) daughter nodes

A given node's daughter nodes constitute an _ordered_ list.

However, you are free to consider this ordering irrelevant. Some
applications do need daughters to be ordered, so I chose to consider this
the general case.

* o A node can appear in only one tree, and only once in that tree

Notably (notable because it doesn't follow from the two above points), a
node cannot appear twice in its mother's daughter list.

* o There's an idea of up versus down

Up means towards to the root, and down means away from the root (and
towards the leaves).

* o There's an idea of left versus right

Left is toward the start (index 0) of a given node's daughter list, and
right is toward the end of a given node's daughter list.

Trees as described above have various applications, among them:
representing syntactic constituency, in formal linguistics; representing
contingencies in a game tree; representing abstract syntax in the parsing
of any computer language -- whether in expression trees for programming
languages, or constituency in the parse of a markup language document.
(Some of these might not use the fact that daughters are ordered.)

(Note: B-Trees are a very special case of the above kinds of trees, and are
best treated with their own class. Check CPAN for modules encapsulating
B-Trees; or if you actually want a database, and for some reason ended up
looking here, go look at the AnyDBM_File manpage.)

Many base classes are not usable except as such -- but 'Tree::DAG_Node' can
be used as a normal class. You can go ahead and say:

use Tree::DAG_Node;
my $root = Tree::DAG_Node->new();
$root->name("I'm the tops");
$new_daughter = Tree::DAG_Node->new();
$new_daughter->name("More");
$root->add_daughter($new_daughter);

and so on, constructing and linking objects from 'Tree::DAG_Node' and
making useful tree structures out of them.

Version: 1.22

Release: 2.1.3

Architecture: noarch

Size: 66.1 KB

Build Time: 2014-10-06 16:43:40 +0200 (over 9 years ago)