package org.opendaylight.yangtools.yang.parser.stmt.reactor;
import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verify;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.MoreObjects;
import com.google.common.collect.AbstractIterator;
-import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterators;
import java.util.AbstractCollection;
import java.util.Arrays;
import java.util.Collection;
* Simple integer-to-StatementContextBase map optimized for size and restricted in scope of operations. It does not
* implement {@link java.util.Map} for simplicity's sake.
*
+ * <p>
+ * Unlike other collections, this view does not detect concurrent modification. Iteration is performed in order of
+ * increasing offset. In face of concurrent modification, number of elements returned through iteration may not match
+ * the size reported via {@link Collection#size()}.
+ *
* @author Robert Varga
*/
-abstract class StatementMap {
+abstract class StatementMap extends AbstractCollection<AbstractResumedStatement<?, ?, ?>> {
private static final class Empty extends StatementMap {
- @Override
- StatementContextBase<?, ?, ?> get(final int index) {
- return null;
+ private static final Iterator<AbstractResumedStatement<?, ?, ?>> EMPTY_ITERATOR;
+
+ static {
+ // This may look weird, but we really want to return two Iterator implementations from StatementMap, so that
+ // users have to deal with bimorphic invocation. Note that we want to invoke hasNext() here, as we want to
+ // initialize state to AbstractIterator.endOfData().
+ final Iterator<AbstractResumedStatement<?, ?, ?>> it = new Regular(0).iterator();
+ verify(!it.hasNext());
+ EMPTY_ITERATOR = it;
}
@Override
- StatementMap put(final int index, final StatementContextBase<?, ?, ?> obj) {
- return index == 0 ? new Singleton(obj) : new Regular(index, obj);
+ AbstractResumedStatement<?, ?, ?> get(final int index) {
+ return null;
}
@Override
- Collection<StatementContextBase<?, ?, ?>> values() {
- return ImmutableList.of();
+ StatementMap put(final int index, final AbstractResumedStatement<?, ?, ?> obj) {
+ return index == 0 ? new Singleton(obj) : new Regular(index, obj);
}
@Override
- int size() {
+ public int size() {
return 0;
}
}
@Override
- int capacity() {
- return 0;
+ public void forEach(final Consumer<? super AbstractResumedStatement<?, ?, ?>> action) {
+ // No-op
+ }
+
+ @Override
+ public Iterator<AbstractResumedStatement<?, ?, ?>> iterator() {
+ return EMPTY_ITERATOR;
}
}
private static final class Regular extends StatementMap {
- private StatementContextBase<?, ?, ?>[] elements;
+ private AbstractResumedStatement<?, ?, ?>[] elements;
private int size;
Regular(final int expectedLimit) {
- elements = new StatementContextBase<?, ?, ?>[expectedLimit];
+ elements = new AbstractResumedStatement<?, ?, ?>[expectedLimit];
}
- Regular(final int index, final StatementContextBase<?, ?, ?> object) {
+ Regular(final int index, final AbstractResumedStatement<?, ?, ?> object) {
this(index + 1, index, object);
}
- Regular(final StatementContextBase<?, ?, ?> object0, final int index,
- final StatementContextBase<?, ?, ?> object) {
+ Regular(final AbstractResumedStatement<?, ?, ?> object0, final int index,
+ final AbstractResumedStatement<?, ?, ?> object) {
this(index + 1, 0, object0);
elements[index] = requireNonNull(object);
size = 2;
}
- Regular(final int expectedLimit, final int index, final StatementContextBase<?, ?, ?> object) {
+ Regular(final int expectedLimit, final int index, final AbstractResumedStatement<?, ?, ?> object) {
this(expectedLimit);
elements[index] = requireNonNull(object);
size = 1;
}
@Override
- StatementContextBase<?, ?, ?> get(final int index) {
+ AbstractResumedStatement<?, ?, ?> get(final int index) {
return index >= elements.length ? null : elements[index];
}
@Override
- StatementMap put(final int index, final StatementContextBase<?, ?, ?> obj) {
+ StatementMap put(final int index, final AbstractResumedStatement<?, ?, ?> obj) {
if (index < elements.length) {
checkArgument(elements[index] == null);
} else {
}
@Override
- Collection<StatementContextBase<?, ?, ?>> values() {
- return new RegularAsCollection<>(elements, size);
- }
-
- @Override
- int size() {
+ public int size() {
return size;
}
}
@Override
- int capacity() {
- return elements.length;
- }
- }
-
- private static final class RegularAsCollection<T> extends AbstractCollection<T> {
- private final T[] elements;
- private final int size;
-
- RegularAsCollection(final T[] elements, final int size) {
- this.elements = requireNonNull(elements);
- this.size = size;
- }
-
- @Override
- public void forEach(final Consumer<? super T> action) {
- for (T e : elements) {
- if (e != null) {
- action.accept(e);
- }
- }
- }
-
- @Override
- public Iterator<T> iterator() {
- return new AbstractIterator<T>() {
+ public Iterator<AbstractResumedStatement<?, ?, ?>> iterator() {
+ return new AbstractIterator<>() {
private int nextOffset = 0;
@Override
- protected T computeNext() {
+ protected AbstractResumedStatement<?, ?, ?> computeNext() {
while (nextOffset < elements.length) {
- final T ret = elements[nextOffset++];
+ final AbstractResumedStatement<?, ?, ?> ret = elements[nextOffset++];
if (ret != null) {
return ret;
}
}
};
}
-
- @Override
- public int size() {
- return size;
- }
}
private static final class Singleton extends StatementMap {
- private final StatementContextBase<?, ?, ?> object;
+ private final AbstractResumedStatement<?, ?, ?> object;
- Singleton(final StatementContextBase<?, ?, ?> object) {
+ Singleton(final AbstractResumedStatement<?, ?, ?> object) {
this.object = requireNonNull(object);
}
@Override
- StatementContextBase<?, ?, ?> get(final int index) {
+ AbstractResumedStatement<?, ?, ?> get(final int index) {
return index == 0 ? object : null;
}
@Override
- StatementMap put(final int index, final StatementContextBase<?, ?, ?> obj) {
+ StatementMap put(final int index, final AbstractResumedStatement<?, ?, ?> obj) {
checkArgument(index != 0);
return new Regular(this.object, index, obj);
}
@Override
- Collection<StatementContextBase<?, ?, ?>> values() {
- return ImmutableList.of(object);
- }
-
- @Override
- int size() {
+ public int size() {
return 1;
}
}
@Override
- int capacity() {
- return 1;
+ public Iterator<AbstractResumedStatement<?, ?, ?>> iterator() {
+ return Iterators.singletonIterator(object);
}
}
* @param index Element index, must be non-negative
* @return Requested element or null if there is no element at that index
*/
- abstract @Nullable StatementContextBase<?, ?, ?> get(int index);
+ abstract @Nullable AbstractResumedStatement<?, ?, ?> get(int index);
/**
* Add a statement at specified index.
* @return New statement map
* @throws IllegalArgumentException if the index is already occupied
*/
- abstract @NonNull StatementMap put(int index, @NonNull StatementContextBase<?, ?, ?> obj);
-
- /**
- * Return a read-only view of the elements in this map. Unlike other maps, this view does not detect concurrent
- * modification. Iteration is performed in order of increasing offset. In face of concurrent modification, number
- * of elements returned through iteration may not match the size reported via {@link Collection#size()}.
- *
- * @return Read-only view of available statements.
- */
- abstract @NonNull Collection<StatementContextBase<?, ?, ?>> values();
-
- abstract int size();
+ abstract @NonNull StatementMap put(int index, @NonNull AbstractResumedStatement<?, ?, ?> obj);
abstract @NonNull StatementMap ensureCapacity(int expectedLimit);
-
- abstract int capacity();
-
- @Override
- public final String toString() {
- return MoreObjects.toStringHelper(StatementMap.class).add("values", values()).toString();
- }
}
Code Review / yangtools.git / blobdiff