xyz.cofe.j2d

Class Enums<N extends GNode>

java.lang.Object

xyz.cofe.j2d.Enums<N>

All Implemented Interfaces:

Iterable<N>

public class Enums<N extends GNode>
extends Object
implements Iterable<N>

Средства для работы с итераторами

Author:

user

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Enums.convertors
static class	Enums.filters
static class	Enums.nodeExtract

Field Summary

Fields

Modifier and Type	Field and Description
protected Iterable<N>	nodes

Constructor Summary

Constructors

Constructor and Description
Enums(Iterable<N> nodes)
Enums(N node)

Method Summary

Modifier and Type	Method and Description
<A> Iterable<A>	as(Class<? extends A> cls)
static Iterable<GNode>	children(GNode node)
<A> Iterable<A>	collect(Convertor<N,A> collector)
int	count()
static int	count(Iterable src)
static <A> Iterable<A>	currentNodes(Iterable<TreeWalk<A>> src)
Enums	each(Reciver<GNode> reciver)
static Iterable<GNode>	empty()
static <N extends GNode> Enums<N>	enums(Iterable<N> nodes)
static <N extends GNode> Enums	enums(N node)
static <A> Iterable<A>	filter(Iterable<A> src, Predicate<A> filter)
Enums	filter(Predicate<N> filter)
Iterable<N>	getNodes()
Iterator<N>	iterator()
Enums<N>	select()
Enums<N>	select(boolean selectNodes)
Enums<N>	selectable()
Enums<N>	selected()
Enums<N>	selected(boolean selected)
static <A> Iterable<A>	single(A node)
Enums<N>	transformable()
static <A> Iterable<TreeWalk<A>>	treeOf(A start, NodesExtracter<A,A> ne)
static <A> Iterable<TreeWalk<A>>	treeOf(A start, NodesExtracter<A,A> ne, Predicate<TreeWalk<A>> followFilter)
static <A extends GNode> Iterable<TreeWalk<A>>	treeOf(A start, NodesExtracter<A,A> ne, Predicate<TreeWalk<A>> followFilter, TreeWalkType followType)
Enums<N>	unselected()
Enums<N>	walk()
static Iterable<GNode>	walk(GNode node)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Field Detail

nodes

protected Iterable<N extends GNode> nodes

Constructor Detail

Enums

public Enums(Iterable<N> nodes)

Enums

public Enums(N node)

Method Detail

filter

public static <A> Iterable<A> filter(Iterable<A> src,
                                     Predicate<A> filter)

empty

public static Iterable<GNode> empty()

single

public static <A> Iterable<A> single(A node)

children

public static Iterable<GNode> children(GNode node)

walk

public static Iterable<GNode> walk(GNode node)

treeOf

public static <A extends GNode> Iterable<TreeWalk<A>> treeOf(A start,
                                                             NodesExtracter<A,A> ne,
                                                             Predicate<TreeWalk<A>> followFilter,
                                                             TreeWalkType followType)

treeOf

public static <A> Iterable<TreeWalk<A>> treeOf(A start,
                                               NodesExtracter<A,A> ne,
                                               Predicate<TreeWalk<A>> followFilter)

treeOf

public static <A> Iterable<TreeWalk<A>> treeOf(A start,
                                               NodesExtracter<A,A> ne)

currentNodes

public static <A> Iterable<A> currentNodes(Iterable<TreeWalk<A>> src)

count

public static int count(Iterable src)

enums

public static <N extends GNode> Enums<N> enums(Iterable<N> nodes)

enums

public static <N extends GNode> Enums enums(N node)

getNodes

public Iterable<N> getNodes()

iterator

public Iterator<N> iterator()

Specified by:

iterator in interface Iterable<N extends GNode>

each

public Enums each(Reciver<GNode> reciver)

count

public int count()

filter

public Enums filter(Predicate<N> filter)

collect

public <A> Iterable<A> collect(Convertor<N,A> collector)

selectable

public Enums<N> selectable()

selected

public Enums<N> selected(boolean selected)

selected

public Enums<N> selected()

unselected

public Enums<N> unselected()

select

public Enums<N> select(boolean selectNodes)

select

public Enums<N> select()

transformable

public Enums<N> transformable()

walk

public Enums<N> walk()

as

public <A> Iterable<A> as(Class<? extends A> cls)