public final E first() { if (isEmpty()) { throw new EmptyListException(); } else { return first; } }
/** * Returns an Iterable object, suitable for using with foreach to iterate * over the current list in reverse order. **/ public Iterable<E> reverseIteration() { return new ListIteratorReverser<E>(listIterator(size())); }
@Override public Cons<VBox[]> initialValue() { return Cons.empty(); } };
public final Cons<E> reverseInto(Cons<E> tail) { Cons<E> result = tail; Cons<E> iter = this; while (iter != EMPTY) { result = result.cons(iter.first); iter = iter.rest; } return result; }
private Pair<RedBlackTreeNode<K,V>,V> insert(K key, V value, Comparator<? super K> comparator, int mode) { Pair<RedBlackTreeNode<K,V>,V> result = new Pair<RedBlackTreeNode<K,V>,V>(); if (comparator == null) { insertComparable((Comparable<K>)key, value, result, mode); } else { insert(key, value, comparator, result, mode); } if (result.first != null) { result.first.color = BLACK; } return result; }
public Iterator<E> iterator(E from, E to) { RedBlackTree<E> lower = getNodeLowerBound(from); RedBlackTree<E> upper = getNodeUpperBound(to); if ((lower == upper) || (lower == null) || (upper == null) || (lower.elem.compareTo(upper.elem) > 0)) { return EMPTY_ITERATOR; } return new BoundedRBTIterator<E>(this, lower, upper); }
public final Cons<E> removeFirst(Object elem) { Cons<E> found = member(elem); if (found == null) { return this; } else { return removeExistingCons(found); } }
@Override public E peekFirst() { try { return get(0); } catch (IndexOutOfBoundsException e) { return null; } }
public RedBlackTree<E> put(E elem) { RedBlackTree<E> result = buildTree(elem); result.color = BLACK; return result; }
BoundedRBTIterator(RedBlackTree<T> root, RedBlackTree<T> from, RedBlackTree<T> to) { super(); this.last = to; findStart(root, from); }
public DefaultDependenceRecord(Object dependent, Method predicate, Set<? extends Depended> depended) { this.dependent = dependent; this.predicate = predicate; this.depended = new VLinkedSet<Depended>(depended); }
@Override public E pollFirst() { try { return remove(0); } catch (IndexOutOfBoundsException e) { return null; } }
RBTIterator(RedBlackTree<T> root) { this(); if (root != EMPTY) { findLeftmost(root); } }
@Override protected Cons<ReadBlock> initialValue() { return Cons.empty(); } };
private void findLeftmost(RedBlackTree<T> node) { while (node.left != EMPTY) { path = path.cons(node); node = node.left; } this.next = node; }
public final Cons<E> rest() { if (isEmpty()) { throw new EmptyListException(); } else { return rest; } }
@Override public Iterator<E> descendingIterator() { return new ListIteratorReverser<E>(listIterator(size())); }
public NestedCommitRecord() { this.committer = null; this.childrenToPropagate = Cons.empty(); this.expectedParentOrecs = Cons.empty(); this.varrayReadsToPropagate = Cons.empty(); this.arrayWritesToPropagate = ReadWriteTransaction.EMPTY_MAP; this.arrayWritesCount = ReadWriteTransaction.EMPTY_MAP; this.commitNumber = 0; this.recordCommitted = true; }
private void findLeftmost(RedBlackTreeNode<K,V> node) { while (node.left != EMPTY) { path = path.cons(node); node = node.left; } this.next = node; }
public ParallelNestedTransaction(ReadWriteTransaction parent, boolean multithreaded) { super(parent); super.ancVersions = EMPTY_VERSIONS; this.nestedReads = ReadWriteTransaction.EMPTY_MAP; this.globalReads = Cons.empty(); }