Android_10.0.0_r40/s

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.tradefed.util;

import java.util.Arrays;

/**
 * A class to represent a lightweight byte array.  The goal of this class is to avoid the
 * significant space overhead of using Java classes.  See, for instance:
 * http://benjchristensen.com/2008/05/27/java-memory-usage-ints/
 */
public class ByteArrayList {
    private byte[] mStorage;
    /** arbitrarily choose 128 bytes as the default size */
    private int mMaxBytes = 128;
    private int mCurBytes = 0;
    private float mGrowthFactor = 2.0f;

    /**
     * Constructs an empty list with an initial capacity of 128 bytes and growth factor of 2.0
     */
    public ByteArrayList() {
        mStorage = new byte[mMaxBytes];
    }

    /**
     * Constructs an empty list with the specified initial capacity, and with a growth factor of 2.0
     *
     * @param defaultSize The initial capacity of the list, in bytes
     */
    public ByteArrayList(int defaultSize) {
        this();
        setSize(defaultSize);
    }

    /**
     * Constructs an empty list with the specified initial capacity and growth factor
     *
     * @param defaultSize The initial capacity of the list, in bytes
     * @param growthFactor The factor by which the capacity is multiplied when the list needs to
     *        auto-resize.  Must be {@code >= 1.1f}.
     */
    public ByteArrayList(int defaultSize, float growthFactor) {
        this(defaultSize);

        if (growthFactor < 1.1f) {
            throw new IllegalArgumentException("Growth factor must be at least 1.1");
        }
        mGrowthFactor = growthFactor;
    }

    // Methods involved in managing size
    /**
     * Trims the capacity of this {@code ByteArrayList} instance to be the list's current size.
     */
    public void trimToSize() {
        setSize(size());
    }

    /**
     * Increases the capacity of this {@code ByteArrayList} instance, if necessary, to ensure that
     * it can hold at least the number of bytes specified by the minimum capacity argument.
     *
     * @param minCapacity The minimum capacity to ensure storage for, in bytes
     */
    public void ensureCapacity(int minCapacity) {
        if (minCapacity < 0) {
            throw new IllegalArgumentException("Minimum capacity must be non-negative");
        } else if (minCapacity <= mMaxBytes) {
            return;
        }

        int curSize = mMaxBytes;
        if (curSize == 0) {
            curSize = 1;
        }
        /**
         * Need to grow the array
         * Want: size * (growthFactor * k) >= minCapacity
         *   So: k >= minCapacity / (size * growthFactor)
         *       k = ceil(minCapacity / size / growthFactor)
         */
        int growthFactorMultiples = (int)Math.ceil(minCapacity / mGrowthFactor / curSize);
        // newSize = oldSize * (growthFactor * k) >= minCapacity, from above
        float newSize = curSize * mGrowthFactor * growthFactorMultiples;
        setSize((int)Math.ceil(newSize));
    }

    /**
     * Sets the storage capacity of the internal storage array to the size specified, truncating the
     * internal byte array if needed.
     *
     * @param size The new capacity of the list, in bytes
     */
    void setSize(int size) {
        if (size < 0) {
            throw new IllegalArgumentException("New size must be non-negative");
        } else if (size < mCurBytes) {
            mCurBytes = size;
        }
        mMaxBytes = size;

        byte[] newStorage = new byte[size];
        System.arraycopy(mStorage, 0, newStorage, 0, mCurBytes);
        mStorage = newStorage;
    }

    // Extra methods specific to this class
    /**
     * Returns a copy of the contents of this {@code ByteArrayList} as a {@code byte[]}.
     *
     * @return A {@code byte[]} copy of the list contents
     */
    public byte[] getContents() {
        byte[] contents = new byte[mCurBytes];
        System.arraycopy(mStorage, 0, contents, 0, mCurBytes);
        return contents;
    }

    // Implement useful methods from the List interface
    /**
     * Appends the specified element to the end of this list
     *
     * @param b The {@code byte} to append to the list
     * @return {@code true}
     */
    public boolean add(byte b) {
        ensureCapacity(mCurBytes + 1);
        mStorage[mCurBytes] = b;
        mCurBytes++;
        return true;
    }

    /**
     * Appends the full contents of the supplied {@code byte[]} to the list.
     *
     * @param src The {@code byte[]} to append contents from
     * @return {@code true}
     */
    public boolean addAll(byte[] src) {
        if (src == null) {
            throw new NullPointerException();
        }

        return addAll(src, 0, src.length);
    }

    /**
     * Appends the specified contents of the supplied {@code byte[]} to the list.
     *
     * @param src The {@code byte[]} to append contents from
     * @param srcOffset The index of first element of {@code src} to append
     * @param length The quantity of bytes to append to the list
     * @return {@code true}
     */
    public boolean addAll(byte[] src, int srcOffset, int length) {
        if (src == null) {
            throw new NullPointerException();
        }

        ensureCapacity(mCurBytes + length);
        System.arraycopy(src, srcOffset, mStorage, mCurBytes, length);
        mCurBytes += length;
        return true;
    }

    /**
     * Appends the full contents of the supplied {@link ByteArrayList} to the list.
     *
     * @param src The {@link ByteArrayList} to append contents from
     * @return {@code true}
     */
    public boolean addall(ByteArrayList src) {
        if (src == null) {
            throw new NullPointerException();
        }

        return addAll(src.getContents());
    }

    /**
     * Removes all of the elements from this list.
     */
    public void clear() {
        mCurBytes = 0;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean equals(Object other) {
        if (!(other instanceof ByteArrayList)) {
            return false;
        }
        ByteArrayList otherList = (ByteArrayList) other;

        if (otherList.size() != size()) {
            return false;
        }
        for (int i = 0; i < size(); i++) {
            if (otherList.get(i) != get(i)) {
                return false;
            }
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int hashCode() {
        return Arrays.hashCode(mStorage);
    }

    /**
     * Returns {@code true} if this list contains no bytes
     */
    public boolean isEmpty() {
        return size() == 0;
    }

    /**
     * Returns the element at the specified position in this list
     *
     * @param idx The index to return
     */
    public byte get(int idx) {
        if (idx < 0 || idx >= size()) {
            throw new IndexOutOfBoundsException();
        }
        return mStorage[idx];
    }

    /**
     * Replaces the element at the specified position in this list with the specified element
     *
     * @param idx The index to replace
     * @param b The {@code byte} to replace at that index
     */
    public byte set(int idx, byte b) {
        if (idx < 0 || idx >= size()) {
            throw new IndexOutOfBoundsException();
        }
        byte curVal = mStorage[idx];
        mStorage[idx] = b;
        return curVal;
    }

    /**
     * Returns the number of bytes in this list
     */
    public int size() {
        return mCurBytes;
    }

    // methods to facilitate testing
    int getMaxSize() {
        return mMaxBytes;
    }
}