Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/HashBag.java')
-rw-r--r--jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/HashBag.java877
1 files changed, 0 insertions, 877 deletions
diff --git a/jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/HashBag.java b/jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/HashBag.java
deleted file mode 100644
index 7be6149149..0000000000
--- a/jpa/plugins/org.eclipse.jpt.utility/src/org/eclipse/jpt/utility/internal/HashBag.java
+++ /dev/null
@@ -1,877 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005, 2010 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- *
- * Contributors:
- * Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.utility.internal;
-
-import java.io.Serializable;
-import java.util.AbstractCollection;
-import java.util.Collection;
-import java.util.ConcurrentModificationException;
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-
-/**
- * This class implements the {@link Bag} interface, backed by a
- * hash table. It makes no guarantees as to the iteration order of
- * the bag's elements; in particular, it does not guarantee the order
- * will remain constant over time. This class permits the <code>null</code>
- * element.
- * <p>
- * This class offers constant time performance for the basic operations
- * (<code>add</code>, <code>remove</code>, <code>contains</code> and
- * <code>size</code>), assuming the hash function disperses the elements
- * properly among the buckets. Iterating over this bag requires time
- * proportional to the sum of the bag's size (the number of elements) plus the
- * "capacity" of the backing hash table (the number of buckets). Thus, it is
- * important not to set the initial capacity too high (or the load factor too
- * low) if iteration performance is important.
- * <p>
- * <strong>Note that this implementation is not synchronized.</strong> If multiple
- * threads access a bag concurrently, and at least one of the threads modifies
- * the bag, it <em>must</em> be synchronized externally. This is typically
- * accomplished by synchronizing on some object that naturally encapsulates
- * the bag. If no such object exists, the bag should be "wrapped" using the
- * <code>Collections.synchronizedCollection</code> method. This is
- * best done at creation time, to prevent accidental unsynchronized access
- * to the bag:
- * <pre>
- * Collection c = Collections.synchronizedCollection(new HashBag(...));
- * </pre>
- * <p>
- * The iterators returned by this class's <code>iterator</code> method are
- * <em>fail-fast</em>: if the bag is modified at any time after the iterator is
- * created, in any way except through the iterator's own <code>remove</code>
- * method, the iterator throws a {@link ConcurrentModificationException}.
- * Thus, in the face of concurrent modification, the iterator fails quickly
- * and cleanly, rather than risking arbitrary, non-deterministic behavior at
- * an undetermined time in the future.
- * <p>
- * Note that the fail-fast behavior of an iterator cannot be guaranteed
- * as it is, generally speaking, impossible to make any hard guarantees in the
- * presence of unsynchronized concurrent modification. Fail-fast iterators
- * throw <code>ConcurrentModificationException</code> on a best-effort basis.
- * Therefore, it would be wrong to write a program that depended on this
- * exception for its correctness: <em>the fail-fast behavior of iterators
- * should be used only to detect bugs.</em>
- *
- * @param <E> the type of elements maintained by the bag
- *
- * @see Collection
- * @see Bag
- * @see SynchronizedBag
- * @see Collections#synchronizedCollection(Collection)
- * @see IdentityHashBag
- */
-public class HashBag<E>
- extends AbstractCollection<E>
- implements Bag<E>, Cloneable, Serializable
-{
- /** The hash table. Resized as necessary. Length MUST Always be a power of two. */
- transient Entry<E>[] table;
-
- /** The total number of entries in the bag. */
- transient int size = 0;
-
- /** The number of UNIQUE entries in the bag. */
- transient int uniqueCount = 0;
-
- /**
- * The hash table is rehashed when its size exceeds this threshold. (The
- * value of this field is <code>(int) (capacity * loadFactor)</code>.)
- *
- * @serial
- */
- private int threshold;
-
- /**
- * The load factor for the hash table.
- *
- * @serial
- */
- private final float loadFactor;
-
- /**
- * The number of times this bag has been structurally modified.
- * Structural modifications are those that change the number of entries in
- * the bag or otherwise modify its internal structure (e.g. rehash).
- * This field is used to make iterators on this bag fail-fast.
- *
- * @see java.util.ConcurrentModificationException
- */
- transient int modCount = 0;
-
- /**
- * The default initial capacity - MUST be a power of two.
- */
- private static final int DEFAULT_INITIAL_CAPACITY = 16;
-
- /**
- * The maximum capacity, used if a higher value is implicitly specified
- * by either of the constructors with arguments.
- * MUST be a power of two <= (1 << 30).
- */
- private static final int MAXIMUM_CAPACITY = 1 << 30;
-
- /**
- * The load factor used when none specified in constructor.
- */
- private static final float DEFAULT_LOAD_FACTOR = 0.75f;
-
- /**
- * Construct a new, empty bag with the
- * default capacity, which is 16, and load factor, which is 0.75.
- */
- public HashBag() {
- this(DEFAULT_INITIAL_CAPACITY);
- }
-
- /**
- * Construct a new, empty bag with the specified initial capacity
- * and the default load factor, which is 0.75.
- *
- * @param initialCapacity the initial capacity
- * @throws IllegalArgumentException if the initial capacity is less
- * than zero
- */
- public HashBag(int initialCapacity) {
- this(initialCapacity, DEFAULT_LOAD_FACTOR, false); // false = do not validate parms
- }
-
- /**
- * Construct a new, empty bag with
- * the specified initial capacity and load factor.
- *
- * @param initialCapacity the initial capacity
- * @param loadFactor the load factor
- * @throws IllegalArgumentException if the initial capacity is less
- * than zero or if the load factor is non-positive
- */
- public HashBag(int initialCapacity, float loadFactor) {
- this(initialCapacity, loadFactor, true); // true = validate parms
- }
-
- private HashBag(int initialCapacity, float loadFactor, boolean validateParms) {
- super();
- int capacity = initialCapacity;
- if (validateParms) {
- if (capacity < 0) {
- throw new IllegalArgumentException("Illegal Initial Capacity: " + capacity); //$NON-NLS-1$
- }
- if (capacity > MAXIMUM_CAPACITY) {
- capacity = MAXIMUM_CAPACITY;
- }
- if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
- throw new IllegalArgumentException("Illegal Load factor: " + loadFactor); //$NON-NLS-1$
- }
-
- // find a power of 2 >= 'initialCapacity'
- capacity = 1;
- while (capacity < initialCapacity) {
- capacity <<= 1;
- }
- }
-
- this.loadFactor = loadFactor;
- this.table = this.buildTable(capacity);
- this.threshold = (int) (capacity * loadFactor);
- }
-
- /**
- * Construct a new bag containing the elements in the specified
- * collection. The bag's load factor will be the default, which is 0.75,
- * and its initial capacity will be sufficient to hold all the elements in
- * the specified collection.
- *
- * @param c the collection whose elements are to be placed into this bag.
- */
- public HashBag(Collection<? extends E> c) {
- this(Math.max((int) (c.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
- this.addAll_(c);
- }
-
- /**
- * Return a hash for the specified object.
- */
- private int hash(Object o) {
- return (o == null) ? 0 : this.tweakHash(o.hashCode());
- }
-
- /**
- * Tweak the specified hash, to defend against poor implementations
- * of {@link Object#hashCode()}.
- */
- private int tweakHash(int h) {
- h ^= (h >>> 20) ^ (h >>> 12);
- return h ^ (h >>> 7) ^ (h >>> 4);
- }
-
- /**
- * Return the index for the specified hash.
- */
- private int index(int hash) {
- return this.index(hash, this.table.length);
- }
-
- /**
- * Return the index for the specified hash
- * within a table with the specified length.
- */
- int index(int hash, int length) {
- return hash & (length - 1);
- }
-
- /**
- * Internal {@link #addAll(Collection)} for construction and cloning.
- * (No check for re-hash; no change to mod count; no return value.)
- */
- private void addAll_(Iterable<? extends E> c) {
- for (E e : c) {
- this.add_(e);
- }
- }
-
- /**
- * Internal {@link #add(Object)} for construction and cloning.
- * (No check for re-hash; no change to mod count; no return value.)
- */
- private void add_(E o) {
- this.add_(o, 1);
- }
-
- /**
- * Internal {@link #add(Object, int)} for construction, cloning, and serialization.
- * (No check for re-hash; no change to mod count; no return value.)
- */
- private void add_(E o, int cnt) {
- int hash = this.hash(o);
- int index = this.index(hash);
- for (Entry<E> e = this.table[index]; e != null; e = e.next) {
- Object eo;
- if ((e.hash == hash) && (((eo = e.object) == o) || ((o != null) && o.equals(eo)))) {
- e.count += cnt;
- this.size += cnt;
- return;
- }
- }
-
- // create the new entry and put it in the table
- Entry<E> e = this.buildEntry(hash, o, cnt, this.table[index]);
- this.table[index] = e;
- this.size += cnt;
- this.uniqueCount++;
- }
-
- /**
- * This implementation simply returns the maintained size.
- */
- @Override
- public int size() {
- return this.size;
- }
-
- /**
- * This implementation simply compares the maintained size to zero.
- */
- @Override
- public boolean isEmpty() {
- return this.size == 0;
- }
-
- /**
- * Search for the object's entry in the hash table by calculating
- * the object's hash code and examining the entries in the corresponding hash
- * table bucket.
- */
- private Entry<E> getEntry(Object o) {
- int hash = this.hash(o);
- for (Entry<E> e = this.table[this.index(hash)]; e != null; e = e.next) {
- Object eo;
- if ((e.hash == hash) && (((eo = e.object) == o) || ((o != null) && o.equals(eo)))) {
- return e;
- }
- }
- return null;
- }
-
- @Override
- public boolean contains(Object o) {
- return this.getEntry(o) != null;
- }
-
- public int count(Object o) {
- Entry<E> e = this.getEntry(o);
- return (e == null) ? 0 : e.count;
- }
-
- /**
- * Rehash the contents of the bag into a new hash table
- * with a larger capacity. This method is called when the
- * number of different elements in the bag exceeds its
- * capacity and load factor.
- */
- private void rehash() {
- Entry<E>[] oldTable = this.table;
- int oldCapacity = oldTable.length;
-
- if (oldCapacity == MAXIMUM_CAPACITY) {
- this.threshold = Integer.MAX_VALUE;
- return;
- }
-
- int newCapacity = 2 * oldCapacity;
- Entry<E>[] newTable = this.buildTable(newCapacity);
-
- for (int i = oldCapacity; i-- > 0; ) {
- for (Entry<E> old = oldTable[i]; old != null; ) {
- Entry<E> e = old;
- old = old.next;
-
- int index = this.index(e.hash, newCapacity);
- e.next = newTable[index];
- newTable[index] = e;
- }
- }
-
- this.table = newTable;
- this.threshold = (int) (newCapacity * this.loadFactor);
- }
-
- // minimize scope of suppressed warnings
- @SuppressWarnings("unchecked")
- private Entry<E>[] buildTable(int capacity) {
- return new Entry[capacity];
- }
-
- /**
- * This implementation searches for the object in the hash table by calculating
- * the object's hash code and examining the entries in the corresponding hash
- * table bucket.
- */
- @Override
- public boolean add(E o) {
- return this.add(o, 1);
- }
-
- /**
- * This implementation searches for the object in the hash table by calculating
- * the object's hash code and examining the entries in the corresponding hash
- * table bucket.
- */
- public boolean add(E o, int cnt) {
- if (cnt <= 0) {
- return false;
- }
- this.modCount++;
- int hash = this.hash(o);
- int index = this.index(hash);
-
- // if the object is already in the bag, simply bump its count
- for (Entry<E> e = this.table[index]; e != null; e = e.next) {
- Object eo;
- if ((e.hash == hash) && (((eo = e.object) == o) || ((o != null) && o.equals(eo)))) {
- e.count += cnt;
- this.size += cnt;
- return true;
- }
- }
-
- // rehash the table if we are going to exceed the threshold
- if (this.uniqueCount >= this.threshold) {
- this.rehash();
- index = this.index(hash); // need to re-calculate the index
- }
-
- // create the new entry and put it in the table
- Entry<E> e = this.buildEntry(hash, o, cnt, this.table[index]);
- this.table[index] = e;
- this.size += cnt;
- this.uniqueCount++;
- return true;
- }
-
- // minimize scope of suppressed warnings
- @SuppressWarnings({ "rawtypes", "unchecked" } )
- private Entry<E> buildEntry(int hash, Object o, int cnt, Entry next) {
- return new Entry<E>(hash, (E) o, cnt, (Entry<E>) next);
- }
-
- /**
- * This implementation searches for the object in the hash table by calculating
- * the object's hash code and examining the entries in the corresponding hash
- * table bucket.
- */
- @Override
- public boolean remove(Object o) {
- return this.remove(o, 1);
- }
-
- /**
- * This implementation searches for the object in the hash table by calculating
- * the object's hash code and examining the entries in the corresponding hash
- * table bucket.
- */
- public boolean remove(Object o, int cnt) {
- if (cnt <= 0) {
- return false;
- }
- int hash = this.hash(o);
- int index = this.index(hash);
-
- for (Entry<E> e = this.table[index], prev = null; e != null; prev = e, e = e.next) {
- Object eo;
- if ((e.hash == hash) && (((eo = e.object) == o) || ((o != null) && o.equals(eo)))) {
- this.modCount++;
- cnt = (cnt < e.count) ? cnt : e.count;
- e.count -= cnt;
- // if we are removing the last element(s), remove the entry from the table
- if (e.count == 0) {
- if (prev == null) {
- this.table[index] = e.next;
- } else {
- prev.next = e.next;
- }
- this.uniqueCount--;
- }
- this.size -= cnt;
- return true;
- }
- }
-
- return false;
- }
-
- /**
- * This implementation simply clears out all of the hash table buckets.
- */
- @Override
- public void clear() {
- Entry<E>[] tab = this.table;
- this.modCount++;
- for (int i = tab.length; i-- > 0; ) {
- tab[i] = null;
- }
- this.size = 0;
- this.uniqueCount = 0;
- }
-
- /**
- * Returns a shallow copy of this bag: the elements
- * themselves are not cloned.
- *
- * @return a shallow copy of this bag.
- */
- @Override
- public HashBag<E> clone() {
- try {
- @SuppressWarnings("unchecked")
- HashBag<E> clone = (HashBag<E>) super.clone();
- clone.table = this.buildTable(this.table.length);
- clone.size = 0;
- clone.uniqueCount = 0;
- clone.modCount = 0;
- clone.addAll_(this);
- return clone;
- } catch (CloneNotSupportedException e) {
- throw new InternalError();
- }
- }
-
-
- /**
- * Hash table collision list entry.
- */
- private static class Entry<E> implements Bag.Entry<E> {
- final int hash;
- final E object;
- int count;
- Entry<E> next;
-
- Entry(int hash, E object, int count, Entry<E> next) {
- this.hash = hash;
- this.object = object;
- this.count = count;
- this.next = next;
- }
-
- // ***** Bag.Entry implementation
- public E getElement() {
- return this.object;
- }
-
- public int getCount() {
- return this.count;
- }
-
- public int setCount(int count) {
- if (count <= 0) {
- throw new IllegalArgumentException("count must be greater than zero: " + count); //$NON-NLS-1$
- }
- int old = this.count;
- this.count = count;
- return old;
- }
-
- @Override
- public boolean equals(Object o) {
- if ( ! (o instanceof Bag.Entry<?>)) {
- return false;
- }
- @SuppressWarnings("rawtypes")
- Bag.Entry e = (Bag.Entry) o;
- return (this.count == e.getCount()) &&
- Tools.valuesAreEqual(this.object, e.getElement());
- }
-
- @Override
- public int hashCode() {
- E o = this.object;
- return (o == null) ? 0 : (this.count * o.hashCode());
- }
-
- @Override
- public String toString() {
- return this.object + "=>" + this.count; //$NON-NLS-1$
- }
- }
-
-
- @Override
- @SuppressWarnings("unchecked")
- public Iterator<E> iterator() {
- return (this.size == 0) ? EMPTY_ITERATOR : new HashIterator();
- }
-
- @SuppressWarnings("unchecked")
- public Iterator<E> uniqueIterator() {
- return (this.size == 0) ? EMPTY_ITERATOR : new UniqueIterator();
- }
-
- public int uniqueCount() {
- return this.uniqueCount;
- }
-
- @SuppressWarnings("unchecked")
- public Iterator<Bag.Entry<E>> entries() {
- return (this.size == 0) ? EMPTY_ITERATOR : new EntryIterator();
- }
-
-
- /**
- * Empty iterator that does just about nothing.
- */
- @SuppressWarnings("rawtypes")
- private static final Iterator EMPTY_ITERATOR = new EmptyIterator();
-
- @SuppressWarnings("rawtypes")
- private static class EmptyIterator implements Iterator {
-
- EmptyIterator() {
- super();
- }
-
- public boolean hasNext() {
- return false;
- }
-
- public Object next() {
- throw new NoSuchElementException();
- }
-
- public void remove() {
- throw new IllegalStateException();
- }
- }
-
-
- private class HashIterator implements Iterator<E> {
- private int index = HashBag.this.table.length; // start at the end of the table
- private Entry<E> nextEntry = null;
- private int nextEntryCount = 0;
- private Entry<E> lastReturnedEntry = null;
-
- /**
- * The modCount value that the iterator believes that the backing
- * bag should have. If this expectation is violated, the iterator
- * has detected a concurrent modification.
- */
- private int expectedModCount = HashBag.this.modCount;
-
- HashIterator() {
- super();
- }
-
- public boolean hasNext() {
- Entry<E> e = this.nextEntry;
- int i = this.index;
- Entry<E>[] tab = HashBag.this.table;
- // Use locals for faster loop iteration
- while ((e == null) && (i > 0)) {
- e = tab[--i]; // move backwards through the table
- }
- this.nextEntry = e;
- this.index = i;
- return e != null;
- }
-
- public E next() {
- if (HashBag.this.modCount != this.expectedModCount) {
- throw new ConcurrentModificationException();
- }
- Entry<E> et = this.nextEntry;
- int i = this.index;
- Entry<E>[] tab = HashBag.this.table;
- // Use locals for faster loop iteration
- while ((et == null) && (i > 0)) {
- et = tab[--i]; // move backwards through the table
- }
- this.nextEntry = et;
- this.index = i;
- if (et == null) {
- throw new NoSuchElementException();
- }
- Entry<E> e = this.lastReturnedEntry = this.nextEntry;
- this.nextEntryCount++;
- if (this.nextEntryCount == e.count) {
- this.nextEntry = e.next;
- this.nextEntryCount = 0;
- }
- return e.object;
- }
-
- public void remove() {
- if (this.lastReturnedEntry == null) {
- throw new IllegalStateException();
- }
- if (HashBag.this.modCount != this.expectedModCount) {
- throw new ConcurrentModificationException();
- }
- int slot = HashBag.this.index(this.lastReturnedEntry.hash, HashBag.this.table.length);
- for (Entry<E> e = HashBag.this.table[slot], prev = null; e != null; prev = e, e = e.next) {
- if (e == this.lastReturnedEntry) {
- HashBag.this.modCount++;
- this.expectedModCount++;
- e.count--;
- if (e.count == 0) {
- // if we are removing the last one, remove the entry from the table
- if (prev == null) {
- HashBag.this.table[slot] = e.next;
- } else {
- prev.next = e.next;
- }
- HashBag.this.uniqueCount--;
- } else {
- // slide back the count to account for the just-removed element
- this.nextEntryCount--;
- }
- HashBag.this.size--;
- this.lastReturnedEntry = null; // it cannot be removed again
- return;
- }
- }
- throw new ConcurrentModificationException();
- }
-
- }
-
-
- private class EntryIterator implements Iterator<Entry<E>> {
- private int index = HashBag.this.table.length; // start at the end of the table
- private Entry<E> nextEntry = null;
- private Entry<E> lastReturnedEntry = null;
-
- /**
- * The modCount value that the iterator believes that the backing
- * bag should have. If this expectation is violated, the iterator
- * has detected a concurrent modification.
- */
- private int expectedModCount = HashBag.this.modCount;
-
- EntryIterator() {
- super();
- }
-
- public boolean hasNext() {
- Entry<E> e = this.nextEntry;
- int i = this.index;
- Entry<E>[] tab = HashBag.this.table;
- // Use locals for faster loop iteration
- while ((e == null) && (i > 0)) {
- e = tab[--i]; // move backwards through the table
- }
- this.nextEntry = e;
- this.index = i;
- return e != null;
- }
-
- public Entry<E> next() {
- if (HashBag.this.modCount != this.expectedModCount) {
- throw new ConcurrentModificationException();
- }
- Entry<E> et = this.nextEntry;
- int i = this.index;
- Entry<E>[] tab = HashBag.this.table;
- // Use locals for faster loop iteration
- while ((et == null) && (i > 0)) {
- et = tab[--i]; // move backwards through the table
- }
- this.nextEntry = et;
- this.index = i;
- if (et == null) {
- throw new NoSuchElementException();
- }
- Entry<E> e = this.lastReturnedEntry = this.nextEntry;
- this.nextEntry = e.next;
- return e;
- }
-
- public void remove() {
- if (this.lastReturnedEntry == null) {
- throw new IllegalStateException();
- }
- if (HashBag.this.modCount != this.expectedModCount) {
- throw new ConcurrentModificationException();
- }
- int slot = HashBag.this.index(this.lastReturnedEntry.hash, HashBag.this.table.length);
- for (Entry<E> e = HashBag.this.table[slot], prev = null; e != null; prev = e, e = e.next) {
- if (e == this.lastReturnedEntry) {
- HashBag.this.modCount++;
- this.expectedModCount++;
- // remove the entry from the table
- if (prev == null) {
- HashBag.this.table[slot] = e.next;
- } else {
- prev.next = e.next;
- }
- HashBag.this.uniqueCount--;
- HashBag.this.size -= this.lastReturnedEntry.count;
- this.lastReturnedEntry = null; // it cannot be removed again
- return;
- }
- }
- throw new ConcurrentModificationException();
- }
-
- }
-
-
- private class UniqueIterator implements Iterator<E> {
- private EntryIterator entryIterator = new EntryIterator();
-
- UniqueIterator() {
- super();
- }
-
- public boolean hasNext() {
- return this.entryIterator.hasNext();
- }
-
- public E next() {
- return this.entryIterator.next().object;
- }
-
- public void remove() {
- this.entryIterator.remove();
- }
-
- }
-
-
- @Override
- public boolean equals(Object o) {
- if (o == this) {
- return true;
- }
- if ( ! (o instanceof Bag<?>)) {
- return false;
- }
- @SuppressWarnings("unchecked")
- Bag<E> b = (Bag<E>) o;
- if (b.size() != this.size()) {
- return false;
- }
- if (b.uniqueCount() != this.uniqueCount()) {
- return false;
- }
- for (Iterator<Bag.Entry<E>> stream = b.entries(); stream.hasNext(); ) {
- Bag.Entry<E> entry = stream.next();
- if (entry.getCount() != this.count(entry.getElement())) {
- return false;
- }
- }
- return true;
- }
-
- @Override
- public int hashCode() {
- int h = 0;
- for (E o : this) {
- if (o != null) {
- h += o.hashCode();
- }
- }
- return h;
- }
-
- /**
- * Save the state of this bag to a stream (i.e. serialize it).
- *
- * @serialData Emit the capacity of the bag (int),
- * followed by the number of unique elements in the bag (int),
- * followed by all of the bag's elements (each an Object) and
- * their counts (each an int), in no particular order.
- */
- private void writeObject(java.io.ObjectOutputStream s)
- throws java.io.IOException {
- // write out the threshold, load factor, and any hidden stuff
- s.defaultWriteObject();
-
- // write out number of buckets
- s.writeInt(this.table.length);
-
- // write out number of unique elements
- s.writeInt(this.uniqueCount);
-
- // write out elements and counts (alternating)
- if (this.uniqueCount > 0) {
- for (Entry<E> entry : this.table) {
- while (entry != null) {
- s.writeObject(entry.object);
- s.writeInt(entry.count);
- entry = entry.next;
- }
- }
- }
- }
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Reconstitute the bag from a stream (i.e. deserialize it).
- */
- private void readObject(java.io.ObjectInputStream s)
- throws java.io.IOException, ClassNotFoundException {
- // read in the threshold, loadfactor, and any hidden stuff
- s.defaultReadObject();
-
- // read in number of buckets and allocate the bucket array
- this.table = this.buildTable(s.readInt());
-
- // read in number of unique elements
- int unique = s.readInt();
-
- // read the elements and counts, and put the elements in the bag
- for (int i = 0; i < unique; i++) {
- @SuppressWarnings("unchecked")
- E element = (E) s.readObject();
- int elementCount = s.readInt();
- this.add_(element, elementCount);
- }
- }
-
-}

Back to the top