FileDocCategorySizeDatePackage
PositionMap.javaAPI DocAndroid 5.1 API12577Thu Mar 12 22:22:56 GMT 2015android.support.v7.widget

PositionMap

public class PositionMap extends Object implements Cloneable
Like a SparseArray, but with the ability to offset key ranges for bulk insertions/deletions.

Fields Summary
private static final Object
DELETED
private boolean
mGarbage
private int[]
mKeys
private Object[]
mValues
private int
mSize
Constructors Summary
public PositionMap()
Creates a new SparseArray containing no mappings.


                
      
        this(10);
public PositionMap(int initialCapacity)
Creates a new PositionMap containing no mappings that will not require any additional memory allocation to store the specified number of mappings. If you supply an initial capacity of 0, the sparse array will be initialized with a light-weight representation not requiring any additional array allocations.

        if (initialCapacity == 0) {
            mKeys = ContainerHelpers.EMPTY_INTS;
            mValues = ContainerHelpers.EMPTY_OBJECTS;
        } else {
            initialCapacity = idealIntArraySize(initialCapacity);
            mKeys = new int[initialCapacity];
            mValues = new Object[initialCapacity];
        }
        mSize = 0;
Methods Summary
public voidappend(int key, E value)
Puts a key/value pair into the array, optimizing for the case where the key is greater than all existing keys in the array.

        if (mSize != 0 && key <= mKeys[mSize - 1]) {
            put(key, value);
            return;
        }

        if (mGarbage && mSize >= mKeys.length) {
            gc();
        }

        int pos = mSize;
        if (pos >= mKeys.length) {
            int n = idealIntArraySize(pos + 1);

            int[] nkeys = new int[n];
            Object[] nvalues = new Object[n];

            // Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
            System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
            System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

            mKeys = nkeys;
            mValues = nvalues;
        }

        mKeys[pos] = key;
        mValues[pos] = value;
        mSize = pos + 1;
public voidclear()
Removes all key-value mappings from this SparseArray.

        int n = mSize;
        Object[] values = mValues;

        for (int i = 0; i < n; i++) {
            values[i] = null;
        }

        mSize = 0;
        mGarbage = false;
public android.support.v7.widget.PositionMapclone()

        PositionMap<E> clone = null;
        try {
            clone = (PositionMap<E>) super.clone();
            clone.mKeys = mKeys.clone();
            clone.mValues = mValues.clone();
        } catch (CloneNotSupportedException cnse) {
            /* ignore */
        }
        return clone;
public voiddelete(int key)
Removes the mapping from the specified key, if there was any.

        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
private voidgc()

        // Log.e("SparseArray", "gc start with " + mSize);

        int n = mSize;
        int o = 0;
        int[] keys = mKeys;
        Object[] values = mValues;

        for (int i = 0; i < n; i++) {
            Object val = values[i];

            if (val != DELETED) {
                if (i != o) {
                    keys[o] = keys[i];
                    values[o] = val;
                    values[i] = null;
                }

                o++;
            }
        }

        mGarbage = false;
        mSize = o;

        // Log.e("SparseArray", "gc end with " + mSize);
public Eget(int key)
Gets the Object mapped from the specified key, or null if no such mapping has been made.

        return get(key, null);
public Eget(int key, E valueIfKeyNotFound)
Gets the Object mapped from the specified key, or the specified Object if no such mapping has been made.

        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i < 0 || mValues[i] == DELETED) {
            return valueIfKeyNotFound;
        } else {
            return (E) mValues[i];
        }
static intidealBooleanArraySize(int need)

        return idealByteArraySize(need);
static intidealByteArraySize(int need)

        for (int i = 4; i < 32; i++)
            if (need <= (1 << i) - 12)
                return (1 << i) - 12;

        return need;
static intidealCharArraySize(int need)

        return idealByteArraySize(need * 2) / 2;
static intidealFloatArraySize(int need)

        return idealByteArraySize(need * 4) / 4;
static intidealIntArraySize(int need)

        return idealByteArraySize(need * 4) / 4;
static intidealLongArraySize(int need)

        return idealByteArraySize(need * 8) / 8;
static intidealObjectArraySize(int need)

        return idealByteArraySize(need * 4) / 4;
static intidealShortArraySize(int need)

        return idealByteArraySize(need * 2) / 2;
public intindexOfKey(int key)
Returns the index for which {@link #keyAt} would return the specified key, or a negative number if the specified key is not mapped.

        if (mGarbage) {
            gc();
        }

        return ContainerHelpers.binarySearch(mKeys, mSize, key);
public intindexOfValue(E value)
Returns an index for which {@link #valueAt} would return the specified key, or a negative number if no keys map to the specified value.

Beware that this is a linear search, unlike lookups by key, and that multiple keys can map to the same value and this will find only one of them.

Note also that unlike most collections' {@code indexOf} methods, this method compares values using {@code ==} rather than {@code equals}.

        if (mGarbage) {
            gc();
        }

        for (int i = 0; i < mSize; i++)
            if (mValues[i] == value)
                return i;

        return -1;
public voidinsertKeyRange(int keyStart, int count)
public intkeyAt(int index)
Given an index in the range 0...size()-1, returns the key from the indexth key-value mapping that this SparseArray stores.

        if (mGarbage) {
            gc();
        }

        return mKeys[index];
public voidput(int key, E value)
Adds a mapping from the specified key to the specified value, replacing the previous mapping from the specified key if there was one.

        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            mValues[i] = value;
        } else {
            i = ~i;

            if (i < mSize && mValues[i] == DELETED) {
                mKeys[i] = key;
                mValues[i] = value;
                return;
            }

            if (mGarbage && mSize >= mKeys.length) {
                gc();

                // Search again because indices may have changed.
                i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
            }

            if (mSize >= mKeys.length) {
                int n = idealIntArraySize(mSize + 1);

                int[] nkeys = new int[n];
                Object[] nvalues = new Object[n];

                // Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
                System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
                System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

                mKeys = nkeys;
                mValues = nvalues;
            }

            if (mSize - i != 0) {
                // Log.e("SparseArray", "move " + (mSize - i));
                System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
                System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
            }

            mKeys[i] = key;
            mValues[i] = value;
            mSize++;
        }
public voidremove(int key)
Alias for {@link #delete(int)}.

        delete(key);
public voidremoveAt(int index)
Removes the mapping at the specified index.

        if (mValues[index] != DELETED) {
            mValues[index] = DELETED;
            mGarbage = true;
        }
public voidremoveAtRange(int index, int size)
Remove a range of mappings as a batch.

param
index Index to begin at
param
size Number of mappings to remove

        final int end = Math.min(mSize, index + size);
        for (int i = index; i < end; i++) {
            removeAt(i);
        }
public voidremoveKeyRange(java.util.ArrayList removedItems, int keyStart, int count)
public voidsetValueAt(int index, E value)
Given an index in the range 0...size()-1, sets a new value for the indexth key-value mapping that this SparseArray stores.

        if (mGarbage) {
            gc();
        }

        mValues[index] = value;
public intsize()
Returns the number of key-value mappings that this SparseArray currently stores.

        if (mGarbage) {
            gc();
        }

        return mSize;
public java.lang.StringtoString()
{@inheritDoc}

This implementation composes a string by iterating over its mappings. If this map contains itself as a value, the string "(this Map)" will appear in its place.

        if (size() <= 0) {
            return "{}";
        }

        StringBuilder buffer = new StringBuilder(mSize * 28);
        buffer.append('{");
        for (int i=0; i<mSize; i++) {
            if (i > 0) {
                buffer.append(", ");
            }
            int key = keyAt(i);
            buffer.append(key);
            buffer.append('=");
            Object value = valueAt(i);
            if (value != this) {
                buffer.append(value);
            } else {
                buffer.append("(this Map)");
            }
        }
        buffer.append('}");
        return buffer.toString();
public EvalueAt(int index)
Given an index in the range 0...size()-1, returns the value from the indexth key-value mapping that this SparseArray stores.

        if (mGarbage) {
            gc();
        }

        return (E) mValues[index];