Tree

Jul 13, 2024

Changes in this version

+ type StatusNode struct

+ Data T

+ FirstChild *StatusNode[S, T]

+ LastChild *StatusNode[S, T]

+ NextSibling *StatusNode[S, T]

+ Parent *StatusNode[S, T]

+ PrevSibling *StatusNode[S, T]

+ Status S

+ func NewStatusNode[S uc.Enumer, T any](status S, data T) *StatusNode[S, T]

+ func (n *StatusNode[S, T]) AddChild(child Noder)

+ func (n *StatusNode[S, T]) AddChildren(children ...*StatusNode[S, T])

+ func (n *StatusNode[S, T]) Copy() uc.Copier

+ func (n *StatusNode[S, T]) DeleteChild(target Noder) []Noder

+ func (n *StatusNode[S, T]) GetAncestors() []Noder

+ func (n *StatusNode[S, T]) GetChildren() []Noder

+ func (n *StatusNode[S, T]) GetData() T

+ func (n *StatusNode[S, T]) GetFirstChild() Noder

+ func (n *StatusNode[S, T]) GetFirstSibling() *StatusNode[S, T]

+ func (n *StatusNode[S, T]) GetLastSibling() *StatusNode[S, T]

+ func (n *StatusNode[S, T]) GetLeaves() []Noder

+ func (n *StatusNode[S, T]) GetParent() Noder

+ func (n *StatusNode[S, T]) HasChild(target *StatusNode[S, T]) bool

+ func (n *StatusNode[S, T]) IsChildOf(target *StatusNode[S, T]) bool

+ func (n *StatusNode[S, T]) IsLeaf() bool

+ func (n *StatusNode[S, T]) IsRoot() bool

+ func (n *StatusNode[S, T]) IsSingleton() bool

+ func (n *StatusNode[S, T]) RemoveNode() []Noder

+ func (n *StatusNode[S, T]) SetParent(parent Noder) bool

+ func (n *StatusNode[S, T]) Size() int

+ func (n *StatusNode[S, T]) TreeOf() *Tree

+ func (t *StatusNode[S, T]) FString(trav *ffs.Traversor, opts ...ffs.Option) error

+ func (t *StatusNode[S, T]) Iterator() uc.Iterater[Noder]

+ func (tn *StatusNode[S, T]) Cleanup()

+ func (tn *StatusNode[S, T]) LinkChildren(children []Noder)

+ type StatusNodeIterator struct

+ func NewStatusNodeIterator[S uc.Enumer, T any](node *StatusNode[S, T]) *StatusNodeIterator[S, T]

+ func (t *StatusNodeIterator[S, T]) Consume() (Noder, error)

+ func (t *StatusNodeIterator[S, T]) Restart()

Jul 10, 2024

Changes in this version

+ var FilterNonNilTree us.PredicateFilter[*Tree]

+ func BFS(tree *Tree, init Infoer, f ObserverFunc) error

+ func DFS(tree *Tree, init Infoer, f ObserverFunc) error

+ func FindBranchingPoint(n Noder) (Noder, Noder, bool)

+ func PrintTree(tree *Tree) ([]string, error)

type Branch

+ func NewBranch(n Noder) *Branch

+ type Builder struct

+ func (b *Builder) Build(elem Noder) (*Tree, error)

+ func (b *Builder) Reset()

+ func (b *Builder) SetInfo(info Infoer)

+ func (b *Builder) SetNextFunc(f NextsFunc)

+ type InfPrinter struct

+ func NewInfPrinter() *InfPrinter

+ func (ip *InfPrinter) Copy() uc.Copier

+ func (ip *InfPrinter) IncIndent()

+ type Infoer interface

+ type NextsFunc func(elem Noder, info Infoer) ([]Noder, error)

+ type Noder interface

+ AddChild func(child Noder)

+ DeleteChild func(target Noder) []Noder

+ GetAncestors func() []Noder

+ GetFirstChild func() Noder

+ GetLeaves func() []Noder

+ GetParent func() Noder

+ IsLeaf func() bool

+ IsSingleton func() bool

+ LinkChildren func(children []Noder)

+ RemoveNode func() []Noder

+ SetParent func(parent Noder) bool

+ Size func() int

+ type ObserverFunc func(data Noder, info Infoer) (bool, error)

type Tree

+ func (t *Tree) PruneFunc(filter us.PredicateFilter[Noder]) bool

type TreeNode

+ FirstChild *TreeNode[T]

+ LastChild *TreeNode[T]

+ NextSibling *TreeNode[T]

+ PrevSibling *TreeNode[T]

+ func (n *TreeNode[T]) GetFirstChild() Noder

+ func (n *TreeNode[T]) GetFirstSibling() *TreeNode[T]

+ func (n *TreeNode[T]) GetLastSibling() *TreeNode[T]

+ func (n *TreeNode[T]) GetLeaves() []Noder

+ func (n *TreeNode[T]) GetParent() Noder

+ func (n *TreeNode[T]) IsSingleton() bool

+ func (n *TreeNode[T]) RemoveNode() []Noder

+ func (n *TreeNode[T]) SetParent(parent Noder) bool

+ func (n *TreeNode[T]) TreeOf() *Tree

+ func (t *TreeNode[T]) Iterator() uc.Iterater[Noder]

+ func (tn *TreeNode[T]) Cleanup()

+ func (tn *TreeNode[T]) LinkChildren(children []Noder)

+ type TreeNodeIterator struct

+ func NewTreeNodeIterator[T any](node *TreeNode[T]) *TreeNodeIterator[T]

+ func (t *TreeNodeIterator[T]) Consume() (Noder, error)

+ func (t *TreeNodeIterator[T]) Restart()

Jun 30, 2024

Changes in this version

type ExtractBranchCmd

+ func (c *ExtractBranchCmd[T]) GetBranch() *Branch[T]

Jun 25, 2024

Changes in this version

+ type Branch struct

+ func (b *Branch[T]) Copy() uc.Copier

+ func (b *Branch[T]) Iterator() uc.Iterater[T]

+ func (b *Branch[T]) Size() int

+ func (b *Branch[T]) Slice() []T

+ type BranchIterator struct

+ func (bi *BranchIterator[T]) Consume() (T, error)

+ func (bi *BranchIterator[T]) Restart()

+ func (bi *BranchIterator[T]) Size() (count int)

+ type ExtractBranchCmd struct

+ func NewExtractBranchCmd[T any](leaf *TreeNode[T]) *ExtractBranchCmd[T]

+ func (c *ExtractBranchCmd[T]) Copy() uc.Copier

+ func (c *ExtractBranchCmd[T]) Execute(data *Tree[T]) error

+ func (c *ExtractBranchCmd[T]) Undo(data *Tree[T]) error

+ type InsertBranchCmd struct

+ func NewInsertBranchCmd[T any](branch *Branch[T]) *InsertBranchCmd[T]

+ func (c *InsertBranchCmd[T]) Copy() uc.Copier

+ func (c *InsertBranchCmd[T]) Execute(data *Tree[T]) error

+ func (c *InsertBranchCmd[T]) Undo(data *Tree[T]) error

+ type StatusInfo struct

+ func NewStatusInfo[S uc.Enumer, T any](data T, status S) *StatusInfo[S, T]

+ func (si *StatusInfo[S, T]) ChangeStatus(status S)

+ func (si *StatusInfo[S, T]) GetData() T

+ func (si *StatusInfo[S, T]) GetStatus() S

+ func (si *StatusInfo[S, T]) SetData(data T)

type Tree

+ func (t *Tree[T]) ExtractBranch(leaf *TreeNode[T], delete bool) *Branch[T]

+ func (t *Tree[T]) InsertBranch(branch *Branch[T]) bool

Jun 24, 2024

Changes in this version

+ func NewTreeWithHistory[T any](data T) *ud.History[*Tree[T]]

+ type CleanupCmd struct

+ func NewCleanupCmd[T any]() *CleanupCmd[T]

+ func (c *CleanupCmd[T]) Copy() uc.Copier

+ func (c *CleanupCmd[T]) Execute(data *Tree[T]) error

+ func (c *CleanupCmd[T]) Undo(data *Tree[T]) error

+ type DeleteBranchContainingCmd struct

+ func NewDeleteBranchContainingCmd[T any](tn *TreeNode[T]) *DeleteBranchContainingCmd[T]

+ func (c *DeleteBranchContainingCmd[T]) Copy() uc.Copier

+ func (c *DeleteBranchContainingCmd[T]) Execute(data *Tree[T]) error

+ func (c *DeleteBranchContainingCmd[T]) Undo(data *Tree[T]) error

+ type ProcessLeavesCmd struct

+ func NewProcessLeavesCmd[T any](f uc.EvalManyFunc[T, T]) *ProcessLeavesCmd[T]

+ func (c *ProcessLeavesCmd[T]) Copy() uc.Copier

+ func (c *ProcessLeavesCmd[T]) Execute(data *Tree[T]) error

+ func (c *ProcessLeavesCmd[T]) Undo(data *Tree[T]) error

+ type PruneBranchesCmd struct

+ func NewPruneBranchesCmd[T any](filter us.PredicateFilter[T]) *PruneBranchesCmd[T]

+ func (c *PruneBranchesCmd[T]) Copy() uc.Copier

+ func (c *PruneBranchesCmd[T]) Execute(data *Tree[T]) error

+ func (c *PruneBranchesCmd[T]) GetOk() bool

+ func (c *PruneBranchesCmd[T]) Undo(data *Tree[T]) error

+ type PruneTreeCmd struct

+ func NewPruneTreeCmd[T any](filter us.PredicateFilter[T]) *PruneTreeCmd[T]

+ func (c *PruneTreeCmd[T]) Copy() uc.Copier

+ func (c *PruneTreeCmd[T]) Execute(data *Tree[T]) error

+ func (c *PruneTreeCmd[T]) GetOk() bool

+ func (c *PruneTreeCmd[T]) Undo(data *Tree[T]) error

+ type RegenerateLeavesCmd struct

+ func NewRegenerateLeavesCmd[T any]() *RegenerateLeavesCmd[T]

+ func (c *RegenerateLeavesCmd[T]) Copy() uc.Copier

+ func (c *RegenerateLeavesCmd[T]) Execute(data *Tree[T]) error

+ func (c *RegenerateLeavesCmd[T]) Undo(data *Tree[T]) error

+ type SetChildrenCmd struct

+ func NewSetChildrenCmd[T any](children []*Tree[T]) *SetChildrenCmd[T]

+ func (c *SetChildrenCmd[T]) Copy() uc.Copier

+ func (c *SetChildrenCmd[T]) Execute(data *Tree[T]) error

+ func (c *SetChildrenCmd[T]) Undo(data *Tree[T]) error

+ type SkipFuncCmd struct

+ func NewSkipFuncCmd[T any](filter us.PredicateFilter[T]) *SkipFuncCmd[T]

+ func (c *SkipFuncCmd[T]) Copy() uc.Copier

+ func (c *SkipFuncCmd[T]) Execute(data *Tree[T]) error

+ func (c *SkipFuncCmd[T]) GetTrees() []*Tree[T]

+ func (c *SkipFuncCmd[T]) Undo(data *Tree[T]) error

type Tree

+ func (t *Tree[T]) Copy() uc.Copier

type TreeNode

+ func (n *TreeNode[T]) GetBranch() []*TreeNode[T]

+ type UpdateLeavesCmd struct

+ func NewUpdateLeavesCmd[T any]() *UpdateLeavesCmd[T]

+ func (c *UpdateLeavesCmd[T]) Copy() uc.Copier

+ func (c *UpdateLeavesCmd[T]) Execute(data *Tree[T]) error

+ func (c *UpdateLeavesCmd[T]) Undo(data *Tree[T]) error

Jun 18, 2024

Changes in this version

type Tree

+ func (t *Tree[T]) Prune(filter us.PredicateFilter[T]) bool

May 23, 2024

Changes in this version

+ func ExtractData[T any](nodes []*TreeNode[T]) []T

+ func FilterNilTree[T any](tree *Tree[T]) bool

+ type ErrMissingRoot struct

+ func NewErrMissingRoot() *ErrMissingRoot

+ func (e *ErrMissingRoot) Error() string

+ type ErrNodeNotPartOfTree struct

+ func NewErrNodeNotPartOfTree() *ErrNodeNotPartOfTree

+ func (e *ErrNodeNotPartOfTree) Error() string

+ type Tree struct

+ func NewTree[T any](data T) *Tree[T]

+ func TreeOf(elem any) *Tree[any]

+ func (t *Tree[T]) Cleanup()

+ func (t *Tree[T]) DeleteBranchContaining(tn *TreeNode[T]) error

+ func (t *Tree[T]) FString(trav *ffs.Traversor)

+ func (t *Tree[T]) FilterChildren(filter slext.PredicateFilter[T]) []*TreeNode[T]

+ func (t *Tree[T]) GetChildren() []T

+ func (t *Tree[T]) GetDirectChildren() []*TreeNode[T]

+ func (t *Tree[T]) GetLeaves() []*TreeNode[T]

+ func (t *Tree[T]) HasChild(filter slext.PredicateFilter[T]) bool

+ func (t *Tree[T]) IsSingleton() bool

+ func (t *Tree[T]) ProcessLeaves(f uc.EvalManyFunc[T, T]) error

+ func (t *Tree[T]) PruneBranches(filter slext.PredicateFilter[T]) bool

+ func (t *Tree[T]) RegenerateLeaves() []*TreeNode[T]

+ func (t *Tree[T]) Root() *TreeNode[T]

+ func (t *Tree[T]) SearchNodes(f slext.PredicateFilter[T]) *TreeNode[T]

+ func (t *Tree[T]) SetChildren(children []*Tree[T]) error

+ func (t *Tree[T]) Size() int

+ func (t *Tree[T]) SkipFilter(filter slext.PredicateFilter[T]) []*Tree[T]

+ func (t *Tree[T]) SnakeTraversal() [][]T

+ func (t *Tree[T]) UpdateLeaves() []*TreeNode[T]

+ type TreeNode struct

+ Data T

+ func FindCommonAncestor[T any](n1, n2 *TreeNode[T]) *TreeNode[T]

+ func NewTreeNode[T any](data T) *TreeNode[T]

+ func (n *TreeNode[T]) AddChild(child *TreeNode[T])

+ func (n *TreeNode[T]) AddChildren(children ...*TreeNode[T])

+ func (n *TreeNode[T]) Copy() intf.Objecter

+ func (n *TreeNode[T]) DeleteChild(target *TreeNode[T]) []*TreeNode[T]

+ func (n *TreeNode[T]) GetAncestors() []*TreeNode[T]

+ func (n *TreeNode[T]) GetChildren() []*TreeNode[T]

+ func (n *TreeNode[T]) GetData() T

+ func (n *TreeNode[T]) HasChild(target *TreeNode[T]) bool

+ func (n *TreeNode[T]) IsChildOf(target *TreeNode[T]) bool

+ func (n *TreeNode[T]) IsLeaf() bool

+ func (n *TreeNode[T]) IsRoot() bool

+ func (n *TreeNode[T]) Leaves() []*TreeNode[T]

+ func (n *TreeNode[T]) Parent() *TreeNode[T]

+ func (n *TreeNode[T]) Size() int

+ func (n *TreeNode[T]) ToTree() *Tree[T]

+ func (t *TreeNode[T]) Equals(other intf.Objecter) bool

+ func (t *TreeNode[T]) FString(trav *ffs.Traversor)

+ func (t *TreeNode[T]) String() string

+ func (tn *TreeNode[T]) FindBranchingPoint() (*TreeNode[T], *TreeNode[T], bool)

+ type Treeer interface

+ TreeOf func() *Tree[T]