Package edu.uiuc.ncsa.qdl.variables

Class QDLList

    • Constructor Detail

      • QDLList

        public QDLList()

      • QDLList

        public QDLList​(long size)

      • QDLList

        public QDLList​(long size,
               Object[] fill)

    • Method Detail

      • getArrayList

        public ArrayList getArrayList()

      • setArrayList

        public void setArrayList​(ArrayList arrayList)

      • hasArrayList

        public boolean hasArrayList()

      • hasSparseEntries

        public boolean hasSparseEntries()

      • subList

        public QDLList subList​(long startIndex,
                       boolean includeStartIndex,
                       long endIndex,
                       boolean includeEndIndex)

      • subListNEW

        public QDLList subListNEW​(long startIndex,
                          boolean includeStartIndex,
                          long count,
                          boolean includeEndIndex)
        Parameters:
        startIndex - - negative means start from end
        includeStartIndex -
        count - - negative means rest of list from start index
        includeEndIndex -
        Returns:

      • subsetEndOfListFromEnd

        public QDLList subsetEndOfListFromEnd​(long startIndex,
                                      boolean includeStartIndex,
                                      long count,
                                      boolean includeEndIndex)

      • subsetBasicCase

        public QDLList subsetBasicCase​(long startIndex,
                               boolean includeStartIndex,
                               long count,
                               boolean includeEndIndex)

      • subsetEndOfList

        public QDLList subsetEndOfList​(long startIndex,
                               boolean includeStartIndex,
                               long count,
                               boolean includeEndIndex)

      • unique

        public QDLList unique()
        Runs over every entry in the stem list (including danglers). result is a standard list (starts at 0, no gaps) of unique elements.
        Returns:

      • get

        public Object get​(long index)

      • getRelativeAddress

        protected Object getRelativeAddress​(long originalIndex)
        Used in cases where the index < 0 and we have to compute it relative to the other indices. Note that for sparse entries, this can be expensive, so a few special cases are handled directly. Searching a sparse list for a relative address will be at worst linear because of the way TreeSet is implemented.
        Parameters:
        originalIndex -
        Returns:

      • getAbsoluteAddress

        protected Object getAbsoluteAddress​(long index)

      • removeByIndex

        public boolean removeByIndex​(long index)
        Remove is a bit different than a java list remove. We allow for gaps and sparse arrays, so in Java [0,1,2,3,4] remove index 2 yields [0,1,3,4] -- still has index 2. QDL would have a result of [0,1]~{3:3,4;4}
        Parameters:
        index -
        Returns:

      • append

        public void append​(Object obj)
        Find the largest element of this list and append the given object to the end of it.
        Parameters:
        obj -

      • appendAll

        public void appendAll​(List<Object> objects)
        Appends all elements in a list. Terrificallty inefficient. Optimize. Someday. Maybe.
        Parameters:
        objects -

      • append

        public void append​(QDLSet set)

      • toString

        public String toString​(int indentFactor,
                       String currentIndent)

      • toString

        public String toString​(int indentFactor)

      • toJSON

        public net.sf.json.JSONArray toJSON()
        This exports the current list as a JSONArray. Note that there is no analog for importing one -- use the QDLStem.fromJSON(JSONObject) to do that, since the result will in general be a stem (if one element of the array is a JSONObject, then the index has to make it a stem -- this is just how the bookkeeping is done).
        Returns:

      • toJSON

        public net.sf.json.JSONArray toJSON​(boolean escapeNames,
                                    int type)

      • inputForm

        public String inputForm​(int indent)

      • inputForm

        public String inputForm()

      • inputForm

        public String inputForm​(int indentFactor,
                        String currentIndent)

      • toArray

        public Object[] toArray​(boolean noGaps,
                        boolean allowStems)
        Convert this to an array of objects. Note that there may be gaps filled in with null values if this is sparse.
        Parameters:
        noGaps - - if true, truncates array at first encountered gap
        allowStems - - if true, hitting a stem throws an exception.
        Returns:

      • dim

        public QDLList dim()
        Get the dimension list for this object. dim(n(3,4,5)) == [3,4,5]
        This id very simple minded and assumes rectangular arrays.
        Returns:

      • getRank

        public Long getRank()

      • values

        public ArrayList values()
        Return all values for this list, including sparse values
        Returns:

      • size

        public int size()
        Specified by:
        size in interface Collection
        Specified by:
        size in interface List

      • arraySize

        public int arraySize()

      • orderedKeys

        public StemKeys orderedKeys()
        Get the keys in a linked hash set. This is specifically for cases where stems have to get them for loops.
        Returns:

      • addAll

        public boolean addAll​(Collection c)
        Add every element in a collection to this list. It will NOT attempt to convert values, it just appends them.
        Specified by:
        addAll in interface Collection
        Specified by:
        addAll in interface List
        Parameters:
        c -
        Returns:

      • hasIndex

        public boolean hasIndex​(long index)

      • set

        public void set​(SparseEntry sparseEntry)
        Add an element in a sparse entry. This puts it in the right place and might adjust indices accordingly.
        Parameters:
        sparseEntry -

      • set

        public void set​(long index,
                Object element)

      • setRelativeIndex

        protected void setRelativeIndex​(long originalIndex,
                                Object element)
        Set a relative value. Note that unlike absolute addresses, relative ones must exist prior to being set. So a.42 can always be set (may result in a sparse entry) but a.(-42) requires there be at least 42 elements
        Parameters:
        originalIndex -
        element -

      • setAbsoluteIndex

        protected void setAbsoluteIndex​(long index,
                                Object element)

      • listInsertFrom

        public void listInsertFrom​(long startIndex,
                           long length,
                           QDLList source,
                           long insertIndex)

      • normalizeIndices

        protected void normalizeIndices()

      • listCopyFrom

        public void listCopyFrom​(long startIndex,
                         long length,
                         QDLList source,
                         long insertIndex)

      • iterator

        public Iterator iterator​(boolean objectsOnly)
        An iterator
        Returns:

      • containsKey

        public boolean containsKey​(Object o)

      • remove

        public boolean remove​(Object o)
        Remove by value from top level only. This fulfills Java's contract for lists/collections, which removes the first instance of this object only.
        Specified by:
        remove in interface Collection
        Specified by:
        remove in interface List
        Parameters:
        o -
        Returns:

      • remove

        public boolean remove​(Collection c)

      • removeAllByValue

        public boolean removeAllByValue​(Collection c,
                                boolean reorderLists)

      • removeAllByValue

        protected boolean removeAllByValue​(Object c,
                                   boolean reorderLists)
        removes a single object from everywhere in this stem.
        Parameters:
        c -
        Returns:

      • addAll

        public boolean addAll​(int index,
                      Collection c)
        Specified by:
        addAll in interface List

      • get

        public Object get​(int index)
        Specified by:
        get in interface List

      • set

        public Object set​(int index,
                  Object element)
        This is mostly used when hot-rodding performance. It only updates the array list backing this object, not any sparse entries. Generally only call it if you have a well-articulated need to do so.
        Specified by:
        set in interface List
        Parameters:
        index -
        element -
        Returns:

      • add

        public void add​(int index,
                Object element)
        Specified by:
        add in interface List

      • remove

        public Object remove​(int index)
        Specified by:
        remove in interface List

      • indexOf

        public int indexOf​(Object o)
        Specified by:
        indexOf in interface List

      • subList

        public List subList​(int fromIndex,
                    int toIndex)
        Specified by:
        subList in interface List

      • descendingIterator

        public Iterator descendingIterator​(boolean objectsOnly)

      • main

        public static void main​(String[] args)

      • otherToString

        protected String otherToString()
        Keep this! It is not used by QDL though and won't show up in any searches of methods used. This is an internal method used by the IDE for debugging. Supremely useful in that context.

      • permuteEntries

        public QDLStem permuteEntries​(List<Long> permutation)
        A very specific utility, used in the transpose function. The assumptions are
        • This list consists entirely indices to a stem, so all entries are longs
        • All the indices are the same length
        • The permutation will be applied to every entry
        • No sparse entries
        This is the case where a QDLStem has the indices in it and we need to permute all of them for a transpose or other operation. This can be very slow and clunky using QDL standard calls, so this is a backdoor for speed to grab the entries directly and remap them. It is not a generally applicable function.
        Parameters:
        permutation -
        Returns: