Package gnu.lists

Class AbstractSequence<E>

  • Direct Known Subclasses:
    Arrays.BuiltArray, ExtSequence, IndirectIndexedSeq, IString, Range, SimpleVector, SubSequence, TransformedArray, TreeList, Values

    public abstract class AbstractSequence<E>
    extends Object
    A collection of default methods for implementing sequence-like classes. Additionally, a sequence may have zero or more attributes, which are name-value pairs. A sequence may also have a named "type". These extensions are to support XML functionality - it might be cleaner to move them to a sub-class of Sequence or some interface. Many of the protected methods in Sequence (such as nextIndex) are only intended to be called from SeqPosition or TreePosition, see those.
    • Field Detail

      • noInts

        public static final int[] noInts
    • Constructor Detail

      • AbstractSequence

        public AbstractSequence()
    • Method Detail

      • size

        public int size()
      • getSize

        public int getSize()
      • isEmpty

        public boolean isEmpty()
      • rank

        public int rank()
      • checkRank

        protected void checkRank​(int i)
      • asImmutable

        public Array<E> asImmutable()
      • get

        public E get()
      • get

        public E get​(int i)
      • get

        public E get​(int i,
                     int j)
      • get

        public E get​(int i,
                     int j,
                     int k,
                     int... rest)
      • get

        public E get​(int[] indexes)
      • checkCanWrite

        protected void checkCanWrite()
      • getRowMajor

        public E getRowMajor​(int index)
      • effectiveIndex

        public int effectiveIndex()
      • effectiveIndex

        public int effectiveIndex​(int index)
      • effectiveIndex

        public int effectiveIndex​(int i,
                                  int j)
      • effectiveIndex

        public int effectiveIndex​(int i,
                                  int j,
                                  int k,
                                  int... rest)
      • effectiveIndex

        public int effectiveIndex​(int[] indexes)
      • getRaw

        public E getRaw​(int index)
      • setBuffer

        protected void setBuffer​(Object obj)
      • setRaw

        public void setRaw​(int index,
                           E value)
        Given an "effective index", set selected element.
      • getBooleanRaw

        public boolean getBooleanRaw​(int index)
      • getCharRaw

        public char getCharRaw​(int index)
      • getByteRaw

        public byte getByteRaw​(int index)
      • getShortRaw

        public short getShortRaw​(int index)
      • getIntRaw

        public int getIntRaw​(int index)
      • getLongRaw

        public long getLongRaw​(int index)
      • getFloatRaw

        public float getFloatRaw​(int index)
      • getDoubleRaw

        public double getDoubleRaw​(int index)
      • getInt

        public int getInt()
      • getInt

        public int getInt​(int i)
      • getInt

        public int getInt​(int i,
                          int j)
      • getInt

        public int getInt​(int i,
                          int j,
                          int k,
                          int... rest)
      • getInt

        public int getInt​(int[] indexes)
      • set

        public void set​(int[] indexes,
                        E value)
      • getLowBound

        public int getLowBound​(int dim)
      • getSize

        public int getSize​(int dim)
      • getElementKind

        public int getElementKind()
      • set

        public E set​(int index,
                     E value)
      • setAt

        public void setAt​(int index,
                          E value)
      • fill

        public void fill​(E value)
      • fillPosRange

        public void fillPosRange​(int fromPos,
                                 int toPos,
                                 E value)
      • fill

        public void fill​(int fromIndex,
                         int toIndex,
                         E value)
      • indexOf

        public int indexOf​(Object o)
        See java.util.List.
      • lastIndexOf

        public int lastIndexOf​(Object o)
        See java.util.List.
      • nextMatching

        public int nextMatching​(int startPos,
                                ItemPredicate type,
                                int endPos,
                                boolean descend)
        Get next matching child or descendent (ignoring attributes).
        Parameters:
        startPos - starting position
        type - a test (predicate) to apply to selected elements
        endPos - stop before endPos
        descend - if true do depth-first traversal.
        Returns:
        poistion of next match or 0 if none found
      • contains

        public boolean contains​(Object o)
        See java.util.List.
      • containsAll

        public boolean containsAll​(Collection<?> c)
        See java.util.List.
      • iterator

        public final Iterator<E> iterator()
      • listIterator

        public final ListIterator<E> listIterator​(int index)
      • addPos

        protected int addPos​(int ipos,
                             E value)
        Add a value at a specified Pos.
        Returns:
        the updated Pos, which is after the inserted value..
      • add

        public boolean add​(E o)
        See java.util.Collection.
      • add

        public void add​(int index,
                        E o)
        See java.util.List.
      • addAll

        public boolean addAll​(Collection<? extends E> c)
        See java.util.Collection.
      • addAll

        public boolean addAll​(int index,
                              Collection<? extends E> c)
        See java.util.Collection.
      • removePos

        public void removePos​(int ipos,
                              int count)
        Remove one or more elements.
        Parameters:
        ipos - position where elements should be removed
        count - if non-negative, remove that number of elements following (poses, posNumber); if negative the negative of the number of elements to remove before (poses, posNumber).
        Throws:
        IndexOutOfBoundsException - if (count >= 0 ? (index < 0 || index + count > size()) : (index + count < 0 || index > size())), where index == nextIndex(ipos, xpos).
      • removePosRange

        protected void removePosRange​(int ipos0,
                                      int ipos1)
        Remove a range where each end-point is a position in a container.
        Parameters:
        ipos0 - start of range, as a poistion
        ipos1 - end of range
        Throws:
        IndexOutOfBoundsException - if nextIndex(ipos0) > nextIndex(ipos1) or nextIndex(ipos0) < 0 or nextIndex(ipos1) > size().
      • remove

        public E remove​(int index)
      • remove

        public boolean remove​(Object o)
      • removeAll

        public boolean removeAll​(Collection<?> c)
      • retainAll

        public boolean retainAll​(Collection<?> c)
      • clear

        public void clear()
      • isAfterPos

        protected boolean isAfterPos​(int ipos)
        Tests whether the position has the "isAfter" property. I.e. if something is inserted at the position, will the iterator end up being after the new data?
      • createPos

        public int createPos​(int index,
                             boolean isAfter)
        Generate a position at a given index. The result is a position cookie that must be free'd with releasePos.
        Parameters:
        index - offset from beginning of desired position
        isAfter - should the position have the isAfter property
        Throws:
        IndexOutOfBoundsException - if index is out of bounds
      • createRelativePos

        public int createRelativePos​(int pos,
                                     int delta,
                                     boolean isAfter)
      • startPos

        public int startPos()
      • endPos

        public int endPos()
      • releasePos

        protected void releasePos​(int ipos)
        Reclaim any resources used by the given position int.
        Parameters:
        ipos - the Pos being free'd.
      • copyPos

        public int copyPos​(int ipos)
        Make a copy of a position int. For simple positions returns the argument. However, if the positions are magic cookies that are actively managed by the sequence (as opposed to for example a simple index), then making a copy may need to increment a reference count, or maybe allocate a new position cookie. In any case, the new position is initialized to the same offset (and isAfter property) as the original.
        Parameters:
        ipos - the position being copied.
        Returns:
        the new position
      • getIndexDifference

        protected int getIndexDifference​(int ipos1,
                                         int ipos0)
        Get offset of (ipos1) relative to (ipos0).
      • nextIndex

        protected int nextIndex​(int ipos)
        Get the offset from the beginning corresponding to a position cookie.
      • fromEndIndex

        protected int fromEndIndex​(int ipos)
      • getContainingSequenceSize

        protected int getContainingSequenceSize​(int ipos)
        Get the size of the (sub-) sequence containing a given position. Normally the same as size(), but may be different if this Sequence is a tree and the position points at an interior node.
      • hasNext

        public boolean hasNext​(int ipos)
      • getNextKind

        public int getNextKind​(int ipos)
      • getNextTypeName

        public String getNextTypeName​(int ipos)
      • getNextTypeObject

        public E getNextTypeObject​(int ipos)
      • hasPrevious

        protected boolean hasPrevious​(int ipos)
        Called by SeqPosition.hasPrevious.
      • nextPos

        public int nextPos​(int ipos)
        Return the next position following the argument. The new position has the isAfter property. The argument is implicitly released (as in releasePos). Returns 0 if we are already at end of file.
      • previousPos

        public int previousPos​(int ipos)
        Return the previous position following the argument. The new position has the isBefore property. The argument is implicitly released (as in releasePos). Returns -1 if we are already at beginning of file.
      • gotoChildrenStart

        public final boolean gotoChildrenStart​(TreePosition pos)
        Set position before first child (of the element following position).
        Returns:
        true if there is a child sequence (which might be empty); false if current position is end of sequence or following element is atomic (cannot have children).
      • firstChildPos

        public int firstChildPos​(int ipos)
        Get position before first child (of the element following position).
        Parameters:
        ipos - parent position. It is not released by this method.
        Returns:
        non-zero position cookie if there is a child sequence (which might be empty); zero if current position is end of sequence or following element is atomic (cannot have children).
      • firstChildPos

        public int firstChildPos​(int ipos,
                                 ItemPredicate predicate)
      • firstAttributePos

        public int firstAttributePos​(int ipos)
        Like firstChildPos. Problem: Should this stop before we get to children? I think so, but that requires changes to TreeList.
      • parentPos

        public int parentPos​(int ipos)
        Get position of parent.
        Parameters:
        ipos - child position. It is not released by this method.
        Returns:
        the p os of the parent, or endPos() is there is no known parent.
      • gotoParent

        protected boolean gotoParent​(TreePosition pos)
      • getAttributeLength

        public int getAttributeLength()
      • getAttribute

        public Object getAttribute​(int index)
      • gotoAttributesStart

        protected boolean gotoAttributesStart​(TreePosition pos)
      • getPosNext

        public Object getPosNext​(int ipos)
        Get the element following the specified position.
        Parameters:
        ipos - the specified position.
        Returns:
        the following element, or eofValue if there is none. Called by SeqPosition.getNext. FIXME Should change eof handling so return type can be E.
      • getPosPrevious

        public Object getPosPrevious​(int ipos)
        Get the element before the specified position.
        Parameters:
        ipos - the specified position.
        Returns:
        the following element, or eofValue if there is none. FIXME Should change eof handling so return type can be E.
      • setPosNext

        protected void setPosNext​(int ipos,
                                  E value)
      • setPosPrevious

        protected void setPosPrevious​(int ipos,
                                      E value)
      • nextIndex

        public final int nextIndex​(SeqPosition pos)
      • equals

        public boolean equals​(int ipos1,
                              int ipos2)
        Compare two positions, and indicate if they are the same position.
      • compare

        public int compare​(int ipos1,
                           int ipos2)
        Compare two positions, and indicate their relative order.
      • toArray

        public Object[] toArray()
      • toArray

        public <T> T[] toArray​(T[] arr)
      • stableCompare

        public int stableCompare​(AbstractSequence other)
        This is used for the XML concept of "document order".
      • compare

        public static int compare​(AbstractSequence seq1,
                                  int pos1,
                                  AbstractSequence seq2,
                                  int pos2)
        This is used for the XML concept of "document order". It is overridden in gnu.xml.NodeTree for a more robust implementation.
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object
      • boundedHash

        public int boundedHash​(int seed,
                               int limit)
      • subSequencePos

        protected Sequence<E> subSequencePos​(int ipos0,
                                             int ipos1)
      • subList

        public List<E> subList​(int fromIx,
                               int toIx)
      • consumeNext

        public boolean consumeNext​(int ipos,
                                   Consumer out)
        Copy an element specified by a position pair to a Consumer.
        Returns:
        if hasNext(ipos).
      • consumePosRange

        public void consumePosRange​(int iposStart,
                                    int iposEnd,
                                    Consumer out)
      • consume

        public void consume​(int fromIndex,
                            int toIndex,
                            Consumer out)
      • consume

        public void consume​(Consumer out)