com.neurosys.domain

Class OrderByRefList<O extends OrderableByRef<Number>>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.ArrayList<O>

com.neurosys.domain.OrderByRefList<O>

Type Parameters:

O - is OrderableByRef by Number type.

All Implemented Interfaces:

Serializable, Cloneable, Iterable<O>, Collection<O>, List<O>, RandomAccess

public class OrderByRefList<O extends OrderableByRef<Number>>
extends ArrayList<O>

A list, when OrderableByRef types are added then they are automatically ordered in the correct order on Add

Ordering

If A->B means B is #getNextRef() of A, and B<-A means B is #getPreviousRef() of A.

Example:
.. lets assume a the following operations: Mirror 1

        A
        B
         C -> D
         D -> A
 

... will result in sequence B, C, D, A

while Mirror 2

         D <- A
             B
             C
         C <- D
 

... will result in sequence C, D, A, B
The above 2 are known as Mirror images of each other, because they represent the same Sequnce but in a different interpretation.

If setReverseNext(boolean) is true, then Mirror2 can be made Mirror1 even though 2 uses "Next" convention as opposed to "Previous".

Cycles

This class does not handle cycles and will throw an IllegalArgumentException if any cycle scenario arises. Following are some cycle scenarios:

• A->B->C->A
• A<-B<-C<-A
• A->B , B<-A TODO: Can consider solving this one

Author:

Arjun Dhar

See Also:

setReverseNext(boolean), Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected Set<Number>	linkedRevNextIds
protected Map<Number,List<Number>>	reverseNextToCurrentMap

Fields inherited from class java.util.AbstractList

modCount

Constructor Summary

Constructors

Constructor and Description
OrderByRefList(Collection<O> c) Add nodes from the Collection c, in the order of OrderableByRef.getNextRef() or OrderableByRef.getPreviousRef(). If no reference data exists then rely on natural order of the given collection.
OrderByRefList(Collection<O> c, boolean reverseNext) Add nodes from the Collection c, in the order of OrderableByRef.getNextRef() or OrderableByRef.getPreviousRef(). If no reference data exists then rely on natural order of the given collection.

Method Summary

Modifier and Type	Method and Description
protected void	detectCycle(Collection<O> c) Throw a RuntimeException type if any cycle detected.
protected List<Number>	getPrevious(O node)
protected List	getSequence(O node)
boolean	isReverseNext() If true will observe all {next & current as --> current & previous}
void	setReverseNext(boolean reverseNext) If true will observe all {next & current as --> current & previous}

Methods inherited from class java.util.ArrayList

add, add, addAll, addAll, clear, clone, contains, ensureCapacity, forEach, get, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, removeIf, removeRange, replaceAll, retainAll, set, size, sort, spliterator, subList, toArray, toArray, trimToSize

Methods inherited from class java.util.AbstractList

equals, hashCode

Methods inherited from class java.util.AbstractCollection

containsAll, toString

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.List

containsAll, equals, hashCode

Methods inherited from interface java.util.Collection

parallelStream, stream

Field Detail

reverseNextToCurrentMap

protected Map<Number,List<Number>> reverseNextToCurrentMap

linkedRevNextIds

protected Set<Number> linkedRevNextIds

Constructor Detail

OrderByRefList

public OrderByRefList(Collection<O> c)

Add nodes from the Collection c, in the order of OrderableByRef.getNextRef() or OrderableByRef.getPreviousRef().
If no reference data exists then rely on natural order of the given collection.

Parameters:

c - as Collection

OrderByRefList

public OrderByRefList(Collection<O> c,
                      boolean reverseNext)

Add nodes from the Collection c, in the order of OrderableByRef.getNextRef() or OrderableByRef.getPreviousRef().
If no reference data exists then rely on natural order of the given collection.

Parameters:

c - as Collection

reverseNext - as boolean. See setReverseNext(boolean)

Method Detail

getSequence

protected List getSequence(O node)

getPrevious

protected List<Number> getPrevious(O node)

Parameters:

node - as OrderableByRef; for which immediate previous nodes to be retrieved

Returns:

List, as multiple vertices can be previous to the same vertex when (reverseNext is true. Nullable

detectCycle

protected void detectCycle(Collection<O> c)

Throw a RuntimeException type if any cycle detected.

Default value:

By default do nothing, as we let pass 2 handle it by checking final size with input size

isReverseNext

public boolean isReverseNext()

If true will observe all {next & current as --> current & previous}

Default value:

false

setReverseNext

public void setReverseNext(boolean reverseNext)

If true will observe all {next & current as --> current & previous}

Default value:

false