Serialized Form

Package edu.emory.mathcs.backport.java.util

Class edu.emory.mathcs.backport.java.util.ArrayDeque extends AbstractCollection implements Serializable

serialVersionUID: 2340985798034038923l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Deserialize this deque.

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

Serialize this deque.

Serial Data:

The current size (int) of the deque, followed by all of its elements (each an object reference) in first-to-last order.

Throws:

java.io.IOException

Class edu.emory.mathcs.backport.java.util.LinkedList extends java.util.AbstractSequentialList implements Serializable

serialVersionUID: 876323262645176354l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

Class edu.emory.mathcs.backport.java.util.PriorityQueue extends AbstractQueue implements Serializable

serialVersionUID: -7720805057305804111l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream is)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream os)
                  throws java.io.IOException

Serial Data:

the length of the array (queue capacity) is stored, followed by all of its elements (as Objects)

Throws:

java.io.IOException

Serialized Fields

size

int size

comparator

java.util.Comparator comparator

Class edu.emory.mathcs.backport.java.util.TreeMap extends AbstractMap implements Serializable

serialVersionUID: 919286545866124006l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

Serialized Fields

comparator

java.util.Comparator comparator

Class edu.emory.mathcs.backport.java.util.TreeMap.Entry extends java.lang.Object implements Serializable

Serialized Fields

key

java.lang.Object key

element

java.lang.Object element

color

boolean color

The node color (RED, BLACK)

left

TreeMap.Entry left

Pointer to left child

right

TreeMap.Entry right

Pointer to right child

parent

TreeMap.Entry parent

Pointer to parent (null if root)

Class edu.emory.mathcs.backport.java.util.TreeSet extends java.util.AbstractSet implements Serializable

serialVersionUID: -2479143000061671589l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

Package edu.emory.mathcs.backport.java.util.concurrent

Class edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue extends AbstractQueue implements Serializable

serialVersionUID: -817911632652898426l

Serialized Fields

items

java.lang.Object[] items

The queued items

takeIndex

int takeIndex

items index for next take, poll or remove

putIndex

int putIndex

items index for next put, offer, or add.

count

int count

Number of items in the queue

lock

ReentrantLock lock

Main lock guarding all access

notEmpty

Condition notEmpty

Condition for waiting takes

notFull

Condition notFull

Condition for waiting puts

Class edu.emory.mathcs.backport.java.util.concurrent.BrokenBarrierException extends java.lang.Exception implements Serializable

serialVersionUID: 7117394618823254244l

Class edu.emory.mathcs.backport.java.util.concurrent.CancellationException extends java.lang.IllegalStateException implements Serializable

serialVersionUID: -9202173006928992231l

Class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap extends AbstractMap implements Serializable

serialVersionUID: 7249069246763182397l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Reconstitute the ConcurrentHashMap instance from a stream (i.e., deserialize it).

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

Save the state of the ConcurrentHashMap instance to a stream (i.e., serialize it).

Serial Data:

the key (Object) and value (Object) for each key-value mapping, followed by a null pair. The key-value mappings are emitted in no particular order.

Throws:

java.io.IOException

Serialized Fields

segmentMask

int segmentMask

Mask value for indexing into segments. The upper bits of a key's hash code are used to choose the segment.

segmentShift

int segmentShift

Shift value for indexing within segments.

segments

ConcurrentHashMap.Segment[] segments

The segments, each of which is a specialized hash table

Class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentLinkedQueue extends AbstractQueue implements Serializable

serialVersionUID: 196745693267521676l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Reconstitute the Queue instance from a stream (that is, deserialize it).

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

Save the state to a stream (that is, serialize it).

Serial Data:

All of the elements (each an E) in the proper order, followed by a null

Throws:

java.io.IOException

Serialized Fields

headLock

java.lang.Object headLock

tailLock

java.lang.Object tailLock

Class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap extends AbstractMap implements Serializable

serialVersionUID: -8627078645895051609l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Reconstitute the map from a stream.

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

Save the state of this map to a stream.

Serial Data:

The key (Object) and value (Object) for each key-value mapping represented by the map, followed by null. The key-value mappings are emitted in key-order (as determined by the Comparator, or by the keys' natural ordering if no Comparator).

Throws:

java.io.IOException

Serialized Fields

comparator

java.util.Comparator comparator

The comparator used to maintain order in this map, or null if using natural ordering.

Class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap.SubMap extends AbstractMap implements Serializable

serialVersionUID: -7647078645895051609l

Serialized Fields

m

ConcurrentSkipListMap m

Underlying map

lo

java.lang.Object lo

lower bound key, or null if from start

hi

java.lang.Object hi

upper bound key, or null if to end

loInclusive

boolean loInclusive

inclusion flag for lo

hiInclusive

boolean hiInclusive

inclusion flag for hi

isDescending

boolean isDescending

direction

Class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListSet extends AbstractSet implements Serializable

serialVersionUID: -2479143111061671589l

Serialized Fields

m

ConcurrentNavigableMap m

The underlying map. Uses Boolean.TRUE as value for each element. This field is declared final for the sake of thread safety, which entails some ugliness in clone()

Class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArrayList extends java.lang.Object implements Serializable

serialVersionUID: 8673264195747942595l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

Class edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet extends java.util.AbstractSet implements Serializable

serialVersionUID: 5457747651344034263l

Serialized Fields

al

CopyOnWriteArrayList al

Class edu.emory.mathcs.backport.java.util.concurrent.ExecutionException extends java.lang.Exception implements Serializable

serialVersionUID: 7830266012832686185l

Class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque extends AbstractQueue implements Serializable

serialVersionUID: -387911632671998426l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Reconstitute this deque from a stream (that is, deserialize it).

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

Save the state of this deque to a stream (that is, serialize it).

Serial Data:

The capacity (int), followed by elements (each an Object) in the proper order, followed by a null

Throws:

java.io.IOException

Serialized Fields

capacity

int capacity

Maximum number of items in the deque

lock

ReentrantLock lock

Main lock guarding all access

notEmpty

Condition notEmpty

Condition for waiting takes

notFull

Condition notFull

Condition for waiting puts

Class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue extends AbstractQueue implements Serializable

serialVersionUID: -6903933977591709194l

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Reconstitute this queue instance from a stream (that is, deserialize it).

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

Save the state to a stream (that is, serialize it).

Serial Data:

The capacity is emitted (int), followed by all of its elements (each an Object) in the proper order, followed by a null

Throws:

java.io.IOException

Serialized Fields

capacity

int capacity

The capacity bound, or Integer.MAX_VALUE if none

count

int count

Current number of elements

takeLock

java.lang.Object takeLock

Lock held by take, poll, etc

putLock

java.lang.Object putLock

Lock held by put, offer, etc

Class edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue extends AbstractQueue implements Serializable

serialVersionUID: 5595510919245408276l

Serialization Methods

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

Saves the state to a stream (that is, serializes it). This merely wraps default serialization within lock. The serialization strategy for items is left to underlying Queue. Note that locking is not needed on deserialization, so readObject is not defined, just relying on default.

Serialized Fields

q

PriorityQueue q

lock

ReentrantLock lock

notEmpty

Condition notEmpty

Class edu.emory.mathcs.backport.java.util.concurrent.RejectedExecutionException extends java.lang.RuntimeException implements Serializable

serialVersionUID: -375805702767069545l

Class edu.emory.mathcs.backport.java.util.concurrent.Semaphore extends java.lang.Object implements Serializable

serialVersionUID: -3222578661600680210l

Serialized Fields

sync

Semaphore.Sync sync

Class edu.emory.mathcs.backport.java.util.concurrent.SynchronousQueue extends AbstractQueue implements Serializable

serialVersionUID: -3223113410248163686l

Serialized Fields

qlock

ReentrantLock qlock

Lock protecting both wait queues

waitingProducers

SynchronousQueue.WaitQueue waitingProducers

Queue holding waiting puts

waitingConsumers

SynchronousQueue.WaitQueue waitingConsumers

Queue holding waiting takes

Class edu.emory.mathcs.backport.java.util.concurrent.TimeoutException extends java.lang.Exception implements Serializable

serialVersionUID: 1900926677490660714l

Class edu.emory.mathcs.backport.java.util.concurrent.TimeUnit extends java.lang.Object implements Serializable

Serialization Methods

readResolve

protected java.lang.Object readResolve()
                                throws java.io.ObjectStreamException

Serialized Fields

index

int index

The ordinal of this unit. This is useful both for TimeUnit.ordinal() and to maintain serialization consistence with earlier versions.

name

java.lang.String name

name of this unit

Package edu.emory.mathcs.backport.java.util.concurrent.atomic

Class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean extends java.lang.Object implements Serializable

serialVersionUID: 4654671469794556979l

Serialized Fields

value

int value

Class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicInteger extends java.lang.Number implements Serializable

serialVersionUID: 6214790243416807050l

Serialized Fields

value

int value

Class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicIntegerArray extends java.lang.Object implements Serializable

serialVersionUID: 2862133569453604235l

Serialized Fields

array

int[] array

Class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong extends java.lang.Number implements Serializable

serialVersionUID: 1927816293512124184l

Serialized Fields

value

long value

Class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLongArray extends java.lang.Object implements Serializable

serialVersionUID: -2308431214976778248l

Serialized Fields

array

long[] array

Class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference extends java.lang.Object implements Serializable

serialVersionUID: -1848883965231344442l

Serialized Fields

value

java.lang.Object value

Class edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReferenceArray extends java.lang.Object implements Serializable

serialVersionUID: -6209656149925076980l

Serialized Fields

array

java.lang.Object[] array

Package edu.emory.mathcs.backport.java.util.concurrent.helpers

Class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue extends WaitQueue implements Serializable

serialVersionUID: 2416444691925378811l

Package edu.emory.mathcs.backport.java.util.concurrent.locks

Class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock extends java.lang.Object implements Serializable

serialVersionUID: 7373984872572414699l

Serialized Fields

sync

ReentrantLock.Sync sync

Class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock extends java.lang.Object implements Serializable

serialVersionUID: -3463448656717690166l

Serialized Fields

readerLock_

ReentrantReadWriteLock.ReadLock readerLock_

writerLock_

ReentrantReadWriteLock.WriteLock writerLock_

sync

edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.Sync sync

Class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock extends java.lang.Object implements Serializable

serialVersionUID: -5992448646407690164l

Serialized Fields

lock

ReentrantReadWriteLock lock

Class edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock extends java.lang.Object implements Serializable

serialVersionUID: -4992448646407690164l

Serialized Fields

lock

ReentrantReadWriteLock lock