212 lines
4.3 KiB
Java
212 lines
4.3 KiB
Java
package com.comphenix.protocol.async;
|
|
|
|
import java.io.Serializable;
|
|
import java.util.Collection;
|
|
import java.util.Iterator;
|
|
import java.util.Queue;
|
|
|
|
import javax.annotation.Nullable;
|
|
|
|
import com.google.common.base.Preconditions;
|
|
|
|
/**
|
|
* Synchronization views copied from Google Guava.
|
|
*
|
|
* @author Kristian
|
|
*/
|
|
class Synchronization {
|
|
|
|
/**
|
|
* Create a synchronized wrapper for the given queue.
|
|
* <p>
|
|
* This wrapper cannot synchronize the iterator(). Callers are expected
|
|
* to synchronize iterators manually.
|
|
* @param queue - the queue to synchronize.
|
|
* @param mutex - synchronization mutex, or NULL to use the queue.
|
|
* @return A synchronization wrapper.
|
|
*/
|
|
public static <E> Queue<E> queue(Queue<E> queue, @Nullable Object mutex) {
|
|
return (queue instanceof SynchronizedQueue) ?
|
|
queue :
|
|
new SynchronizedQueue<E>(queue, mutex);
|
|
}
|
|
|
|
private static class SynchronizedObject implements Serializable {
|
|
private static final long serialVersionUID = -4408866092364554628L;
|
|
|
|
final Object delegate;
|
|
final Object mutex;
|
|
|
|
SynchronizedObject(Object delegate, @Nullable Object mutex) {
|
|
this.delegate = Preconditions.checkNotNull(delegate);
|
|
this.mutex = (mutex == null) ? this : mutex;
|
|
}
|
|
|
|
Object delegate() {
|
|
return delegate;
|
|
}
|
|
|
|
// No equals and hashCode; see ForwardingObject for details.
|
|
|
|
@Override
|
|
public String toString() {
|
|
synchronized (mutex) {
|
|
return delegate.toString();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static class SynchronizedCollection<E> extends SynchronizedObject implements Collection<E> {
|
|
private static final long serialVersionUID = 5440572373531285692L;
|
|
|
|
private SynchronizedCollection(Collection<E> delegate,
|
|
@Nullable Object mutex) {
|
|
super(delegate, mutex);
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
Collection<E> delegate() {
|
|
return (Collection<E>) super.delegate();
|
|
}
|
|
|
|
@Override
|
|
public boolean add(E e) {
|
|
synchronized (mutex) {
|
|
return delegate().add(e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean addAll(Collection<? extends E> c) {
|
|
synchronized (mutex) {
|
|
return delegate().addAll(c);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
synchronized (mutex) {
|
|
delegate().clear();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean contains(Object o) {
|
|
synchronized (mutex) {
|
|
return delegate().contains(o);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean containsAll(Collection<?> c) {
|
|
synchronized (mutex) {
|
|
return delegate().containsAll(c);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
synchronized (mutex) {
|
|
return delegate().isEmpty();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Iterator<E> iterator() {
|
|
return delegate().iterator(); // manually synchronized
|
|
}
|
|
|
|
@Override
|
|
public boolean remove(Object o) {
|
|
synchronized (mutex) {
|
|
return delegate().remove(o);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean removeAll(Collection<?> c) {
|
|
synchronized (mutex) {
|
|
return delegate().removeAll(c);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean retainAll(Collection<?> c) {
|
|
synchronized (mutex) {
|
|
return delegate().retainAll(c);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
synchronized (mutex) {
|
|
return delegate().size();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Object[] toArray() {
|
|
synchronized (mutex) {
|
|
return delegate().toArray();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public <T> T[] toArray(T[] a) {
|
|
synchronized (mutex) {
|
|
return delegate().toArray(a);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private static class SynchronizedQueue<E> extends SynchronizedCollection<E> implements Queue<E> {
|
|
private static final long serialVersionUID = 1961791630386791902L;
|
|
|
|
SynchronizedQueue(Queue<E> delegate, @Nullable Object mutex) {
|
|
super(delegate, mutex);
|
|
}
|
|
|
|
@Override
|
|
Queue<E> delegate() {
|
|
return (Queue<E>) super.delegate();
|
|
}
|
|
|
|
@Override
|
|
public E element() {
|
|
synchronized (mutex) {
|
|
return delegate().element();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean offer(E e) {
|
|
synchronized (mutex) {
|
|
return delegate().offer(e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public E peek() {
|
|
synchronized (mutex) {
|
|
return delegate().peek();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public E poll() {
|
|
synchronized (mutex) {
|
|
return delegate().poll();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public E remove() {
|
|
synchronized (mutex) {
|
|
return delegate().remove();
|
|
}
|
|
}
|
|
}
|
|
}
|