xapi.collect.impl

Class AbstractLinkedList<T,N extends AbstractLinkedList.Node<T,N>,L extends AbstractLinkedList<T,N,L>>

java.lang.Object

xapi.collect.impl.AbstractLinkedList<T,N,L>

All Implemented Interfaces:

Iterable<T>

Direct Known Subclasses:

SimpleLinkedList, SimpleStack

public abstract class AbstractLinkedList<T,N extends AbstractLinkedList.Node<T,N>,L extends AbstractLinkedList<T,N,L>>
extends Object
implements Iterable<T>

A simple base class for implementing linked lists. The default implementation is uni-directional (a SimpleStack), but it leaves room to be extended into a doubly-linked list (SimpleLinkedList).

Author:

"James X. Nelson (james@wetheinter.net)"

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	AbstractLinkedList.Node<T,N extends AbstractLinkedList.Node<T,N>>
protected class	AbstractLinkedList.NodeIterator

Constructor Summary

Constructors

Constructor and Description
AbstractLinkedList()

Method Summary

Modifier and Type	Method and Description
L	add(T item)
void	clear()
L	consume(L other) Forcibly takes all elements from one stack and attaches them to this.
T	head()
boolean	isEmpty()
Iterator<T>	iterator()
String	join(String separator) toStrings the items in the stack with the specified separator
protected abstract N	newNode(T item) Called whenever a node is created, including the head node.
protected void	onAdd(N previous, N next)
T	tail()
String	toString()

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

AbstractLinkedList

public AbstractLinkedList()

Method Detail

add

public L add(T item)

clear

public void clear()

consume

public L consume(L other)

Forcibly takes all elements from one stack and attaches them to this.

This method destroys the stack you send to it.

Note that it is threadsafe with respect to the stack consuming, but not so with the stack being consumed (deadlock's no fun).

Since you are destroying it anyway, chances are the stack is getting gc'd as soon as it pops off the, well... [execution] stack!

This method is destructive because you _really_ don't want to allow cyclic references when two stacks reference each other.

Returns:

head

public T head()

isEmpty

public boolean isEmpty()

iterator

public Iterator<T> iterator()

Specified by:

iterator in interface Iterable<T>

join

public String join(String separator)

toStrings the items in the stack with the specified separator

tail

public T tail()

toString

public String toString()

Overrides:

toString in class Object

newNode

protected abstract N newNode(T item)

Called whenever a node is created, including the head node.

Parameters:

item - -> The item that will become the value for this node. Expect a null for the head node.

onAdd

protected void onAdd(N previous,
                     N next)