/*
 * Copyright (c) 2011-2018 Contributors to the Eclipse Foundation
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 * which is available at https://www.apache.org/licenses/LICENSE-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 */

package io.vertx.core.impl.utils;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

A concurrent cyclic sequence of elements that can be used for round robin.

The sequence is immutable and modifications are done with copy-on-write using add(Object) and remove(Object) to return a modified copy of the current instance.

The internal counter uses a volatile index, so it can be incremented concurrently by several threads without locking.
Author:Tim Fox, Julien Viet
/** * A concurrent cyclic sequence of elements that can be used for round robin. * <p/> * The sequence is immutable and modifications are done with copy-on-write using * {@link #add(Object)} and {@link #remove(Object)} to return a modified copy of the current instance. * <p/> * The internal counter uses a volatile index, so it can be incremented concurrently by several * threads without locking. * * @author <a href="http://tfox.org">Tim Fox</a> * @author <a href="mailto:julien@julienviet.com">Julien Viet</a> */
public class ConcurrentCyclicSequence<T> implements Iterable<T>, Iterator<T> { private static final Object[] EMPTY_ARRAY = new Object[0]; private final AtomicInteger pos; private final Object[] elements;
Create a new empty sequence.
/** * Create a new empty sequence. */
public ConcurrentCyclicSequence() { this(0, EMPTY_ARRAY); }
Create a new empty sequence.
/** * Create a new empty sequence. */
@SafeVarargs public ConcurrentCyclicSequence(T... elements) { this(0, Arrays.copyOf(elements, elements.length, Object[].class)); } private ConcurrentCyclicSequence(int pos, Object[] elements) { this.pos = new AtomicInteger(pos); this.elements = elements; }
Returns:the current index
/** * @return the current index */
public int index() { return elements.length > 0 ? pos.get() % elements.length : 0; }
Returns:the first element or null when the sequence is empty
/** * @return the first element or {@code null} when the sequence is empty */
@SuppressWarnings("unchecked") public T first() { return (T) (elements.length > 0 ? elements[0] : null); }
Copy the current sequence, add element at the tail of this sequence and returns it.
Params:
  • element – the element to add
Returns:the resulting sequence
/** * Copy the current sequence, add {@code element} at the tail of this sequence and returns it. * @param element the element to add * @return the resulting sequence */
public ConcurrentCyclicSequence<T> add(T element) { int len = elements.length; Object[] copy = Arrays.copyOf(elements, len + 1); copy[len] = element; return new ConcurrentCyclicSequence<>(pos.get(), copy); }
Remove the first occurrence of element in this sequence and returns it.

If the sequence does not contains element, this instance is returned instead.
Params:
  • element – the element to remove
Returns:the resulting sequence
/** * Remove the first occurrence of {@code element} in this sequence and returns it. * <p/> * If the sequence does not contains {@code element}, this instance is returned instead. * * @param element the element to remove * @return the resulting sequence */
public ConcurrentCyclicSequence<T> remove(T element) { int len = elements.length; for (int i = 0;i < len;i++) { if (Objects.equals(element, elements[i])) { if (len > 1) { Object[] copy = new Object[len - 1]; System.arraycopy(elements,0, copy, 0, i); System.arraycopy(elements, i + 1, copy, i, len - i - 1); return new ConcurrentCyclicSequence<>(pos.get() % copy.length, copy); } else { return new ConcurrentCyclicSequence<>(); } } } return this; }
Returns:always true
/** * @return always {@code true} */
@Override public boolean hasNext() { return true; }
Returns:the next element in the sequence
/** * @return the next element in the sequence */
@SuppressWarnings("unchecked") @Override public T next() { int len = elements.length; switch (len) { case 0: return null; case 1: return (T) elements[0]; default: int p; p = pos.getAndIncrement(); return (T) elements[Math.abs(p % len)]; } }
Returns:the size of this sequence
/** * @return the size of this sequence */
public int size() { return elements.length; }
Returns:an iterator starting at the first element of the sequence, the iterator will not throw ConcurrentModificationException
/** * @return an iterator starting at the first element of the sequence, the iterator will not throw {@link ConcurrentModificationException} */
@Override @SuppressWarnings("unchecked") public Iterator<T> iterator() { return Arrays.asList((T[]) elements).iterator(); } }