File perl-Tree-DAG_Node.spec of Package perl-Tree-DAG_Node

# spec file for package perl-Tree-DAG_Node
# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany.
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
# upon. The license for this file, and modifications and additions to the
# file, is the same license as for the pristine package itself (unless the
# license for the pristine package is not an Open Source License, in which
# case the license is the MIT License). An "Open Source License" is a
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.

# Please submit bugfixes or comments via

Name:           perl-Tree-DAG_Node
Version:        1.18
Release:        0
%define cpan_name Tree-DAG_Node
Summary:        An N-ary tree
License:        Artistic-2.0
Group:          Development/Libraries/Perl
BuildArch:      noarch
BuildRoot:      %{_tmppath}/%{name}-%{version}-build
BuildRequires:  perl
BuildRequires:  perl-macros
BuildRequires:  perl(File::Slurp) >= 9999.19
BuildRequires:  perl(File::Spec) >= 3.4
BuildRequires:  perl(File::Temp) >= 0.2301
BuildRequires:  perl(Module::Build) >= 0.38
BuildRequires:  perl(Test::More) >= 0.98
#BuildRequires: perl(Tree::DAG_Node)
Requires:       perl(File::Slurp) >= 9999.19
Requires:       perl(File::Spec) >= 3.4
Requires:       perl(File::Temp) >= 0.2301

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

* 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();

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

%setup -q -n %{cpan_name}-%{version}

%{__perl} Build.PL installdirs=vendor
./Build build flags=%{?_smp_mflags}

./Build test

./Build install destdir=%{buildroot} create_packlist=0

%files -f %{name}.files
%doc Changelog.ini Changes README scripts xt