src/com/android/tradefed/util/ByteArrayList.java - platform/tools/tradefederation - Git at Google

 /*
  * 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;
     }
 }
	/*
	* 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;
	}
	}