/ 
Quiq-1.135
River stage zero No dependents
/ Quiq::TreeFormatter

NAME

Quiq::TreeFormatter - Erzeugung von Baumdarstellungen

BASE CLASS

Quiq::Hash

SYNOPSIS

Der Code

use Quiq::TreeFormatter;

my $t = Quiq::TreeFormatter->new([
    [0,'A'],
    [1,'B'],
    [2,'C'],
    [3,'D'],
    [2,'E'],
    [2,'F'],
    [3,'G'],
    [4,'H'],
    [1,'I'],
    [1,'J'],
    [2,'K'],
    [2,'L'],
    [1,'M'],
    [2,'N'],
]);

print $t->asText;

produziert

+--A
   |
   +--B
   |  |
   |  +--C
   |  |  |
   |  |  +--D
   |  |
   |  +--E
   |  |
   |  +--F
   |     |
   |     +--G
   |        |
   |        +--H
   |
   +--I
   |
   +--J
   |  |
   |  +--K
   |  |
   |  +--L
   |
   +--M
      |
      +--N

DESCRIPTION

Ein Objekt der Klasse repräsentiert einen Baum, der mit Methoden der Klasse dargestellt (visualisiert) werden kann. Die Baumstruktur wird als eine Liste von (minestens zweielementigen) Tupeln [$level,$node,...] an den Konstruktor übergeben. Ein Tupel besteht aus der Angabe der Ebene des Knotens, des Knotens selbst und optional weiteren - frei definierbaren - Informationen, z.B. ob der Subbaum des Knotens ausgeblendet wurde. Die zusätzliche Information kann in der getText-Callback-Methode genutzt werden, um den betreffenden Knoten besonders darzustellen. Der Knoten $node kann ein Objekt oder ein Text sein. Die Ebene $level ist eine natürliche Zahl im Wertebereich von 0 (Wurzelknoten) bis n. Die Paar-Liste kann aus irgendeiner Baumstruktur mit einer rekursiven Funktion erzeugt werden (siehe Abschnitt "EXAMPLE").

EXAMPLE

Baumknoten als Texte

Siehe SYNOPSIS.

Rekursive Methode mit Stop-Kennzeichen

Die folgende Methode erkennt, wenn ein Knoten wiederholt auftritt, kennzeichnet diesen mit einem Stop-Kennzeichen und steigt dann nicht in den Subbaum ab. Dies verhindert redundante Baumteile und u.U. eine Endlos-Rekursion (wenn die Wiederholung auf einem Pfad vorkommt).

sub hierarchy {
    my $self = shift;
    my $stopH = shift || {};

    my $stop = $stopH->{$self}++;
    if (!$stop) {
        my @arr;
        for my $node ($self->subNodes) {
            push @arr,map {$_->[0]++; $_} $node->hierarchy($stopH);
        }
    }
    unshift @arr,[0,$self,$stop];

    return wantarray? @arr: \@arr;
}

Baumknoten als Objekte

Hier ein Beispiel für eine rekursive Methode einer Anwendung, die eine Klassenhierarchie für eine bestimmte Klasse ($self) ermittelt. Die Methode liefert die Klassenhierarchie als Paar-Liste für Quiq::TreeFormatter:

sub classHierarchy {
    my $self = shift;

    my @arr;
    for my $cls ($self->subClasses) {
        push @arr,map {$_->[0]++; $_} $cls->classHierarchy;
    }
    unshift @arr,[0,$self];

    return wantarray? @arr: \@arr;
}

Hier sind die Knoten $node Objekte, deren Text für die Darstellung im Baum durch eine anonyme Subroutine produziert wird. Die Subroutine wird mittels der Option -getText an $t->asText() übergeben:

my $cls = $cop->findEntity('Quiq/ContentProcessor/Type');
my $arrA = $cls->classHierarchy;
print Quiq::TreeFormatter->new($arrA)->asText(
    -getText => sub {
        my ($cls,$stop) = @_;

        my $str = $cls->name."\n";
        for my $grp ($cls->groups) {
            $str .= sprintf ": %s\n",$grp->title;
            for my $mth ($grp->methods) {
                $str .= sprintf ":   %s()\n",$mth->name;
            }
        }

        return $str;
    },
);

Ein Ausschnitt aus der produzierten Ausgabe:

+--Quiq/ContentProcessor/Type
   : Erzeugung
   :   create()
   : Objektmethoden
   :   entityFile()
   :   entityId()
   :   entityType()
   :   files()
   :   fileSource()
   :   fileSourceRef()
   :   appendFileSource()
   :   name()
   :   pureCode()
   : Intern
   :   needsTest()
   :   needsUpdate()
   |
   +--Yeah/Type
      |
      +--Yeah/Type/Export
      |  : Erzeugung
      |  :   create()
      |  : Entitäten
      |  :   entities()
      |  : Reguläre Ausdrücke
      |  :   excludeRegex()
      |  :   selectRegexes()
      |  : Verzeichnisse
      |  :   adminDirectories()
      |  :   rootDirectory()
      |  : Verzeichnisse
      |  :   subDirectories()
      |  : Export
      |  :   rewriteRules()
      |  :   export()
      |
      +--Yeah/Type/Language
      |
      +--Yeah/Type/Library
      |
      +--Yeah/Type/Package
      |  : Erzeugung
      |  :   create()
      |  : Eigenschaften
      |  :   level()
      |  :   levelName()
      |  : Entitäten
      |  :   entities()
      |  :   hierarchy()
      |  :   package()
      |  :   subPackages()
      |  : Reguläre Ausdrücke
      |  :   regexes()
      |
      ...

METHODS

Konstruktor

new() - Instantiiere Baum-Objekt

Synopsis

$t = $class->new(\@tuples);

Arguments

@tuples

Liste von Tupeln [$level, $node, ...]. Die Komponenten ... werden transparent weitergereicht.

Returns

Referenz auf Baum-Objekt.

Description

Instantiiere ein Baum-Objekt und liefere eine Referenz auf dieses Objekt zurück.

Darstellung

asText() - Erzeuge Text-Repräsentation des Baums

Synopsis

$str = $t->asText(@opt);

Options

-format => 'debug'|'compact'|'tree' (Default: 'tree')

Format der Ausgabe (s.u.)

-getText => sub { my ($node,@args) = @_; ... return $text }

Callback-Funktion zum Ermitteln des Textes des Knotens. Der Text kann mehrzeilig sein.

Returns

Baumdarstellung (String)

Description

Erzeuge eine Text-Repräsentation des Baums und liefere diese zurück.

debug

0 0 A
1 1   B
2 1     C
3 0       D
2 1     E
2 0     F
3 0       G
4 0         H
1 1   I
1 1   J
2 1     K
2 0     L
1 0   M
2 0     N

compact

A
  B
    C
      D
    E
    F
      G
        H
  I
  J
    K
    L
  M
    N

tree

+--A
   |
   +--B
   |  |
   |  +--C
   |  |  |
   |  |  +--D
   |  |
   |  +--E
   |  |
   |  +--F
   |     |
   |     +--G
   |        |
   |        +--H
   |
   +--I
   |
   +--J
   |  |
   |  +--K
   |  |
   |  +--L
   |
   +--M
      |
      +--N

VERSION

1.135

AUTHOR

Frank Seitz, http://fseitz.de/

COPYRIGHT

Copyright (C) 2019 Frank Seitz

LICENSE

This code is free software; you can redistribute it and/or modify it under the same terms as Perl itself.