X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-reactor%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fstmt%2Freactor%2FStatementMap.java;h=bda208e531519617f5adfab63d0e522cdc3231b1;hb=cf709b80201927b32ef95cd8d8e9aa061e0d2cf3;hp=1f9be29ca9c440180b902f1b113bc1849328d56a;hpb=00c0342a4c5703bd4718e71a9979f410df124bd8;p=yangtools.git diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java index 1f9be29ca9..bda208e531 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java @@ -10,7 +10,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.reactor; import static com.google.common.base.Preconditions.checkArgument; import static java.util.Objects.requireNonNull; -import com.google.common.base.Preconditions; import com.google.common.collect.AbstractIterator; import com.google.common.collect.ImmutableList; import java.util.AbstractCollection; @@ -18,8 +17,8 @@ import java.util.Arrays; import java.util.Collection; import java.util.Iterator; import java.util.function.Consumer; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; /** * Simple integer-to-StatementContextBase map optimized for size and restricted in scope of operations. It does not @@ -35,8 +34,8 @@ abstract class StatementMap { } @Override - StatementMap put(final int index, final StatementContextBase object) { - return index == 0 ? new Singleton(object) : new Regular(index, object); + StatementMap put(final int index, final StatementContextBase obj) { + return index == 0 ? new Singleton(obj) : new Regular(index, obj); } @Override @@ -48,72 +47,93 @@ abstract class StatementMap { int size() { return 0; } + + @Override + StatementMap ensureCapacity(final int expectedLimit) { + return expectedLimit < 2 ? this : new Regular(expectedLimit); + } + + @Override + int capacity() { + return 0; + } } private static final class Regular extends StatementMap { private StatementContextBase[] elements; + private int size; + + Regular(final int expectedLimit) { + elements = new StatementContextBase[expectedLimit]; + } Regular(final int index, final StatementContextBase object) { - elements = new StatementContextBase[index + 1]; - elements[index] = requireNonNull(object); + this(index + 1, index, object); } Regular(final StatementContextBase object0, final int index, final StatementContextBase object) { - elements = new StatementContextBase[index + 1]; - elements[0] = requireNonNull(object0); + this(index + 1, 0, object0); + elements[index] = requireNonNull(object); + size = 2; + } + + Regular(final int expectedLimit, final int index, final StatementContextBase object) { + this(expectedLimit); elements[index] = requireNonNull(object); + size = 1; } @Override StatementContextBase get(final int index) { - if (index >= elements.length) { - return null; - } - - return elements[index]; + return index >= elements.length ? null : elements[index]; } @Override - StatementMap put(final int index, final StatementContextBase object) { + StatementMap put(final int index, final StatementContextBase obj) { if (index < elements.length) { checkArgument(elements[index] == null); } else { + // FIXME: detect linear growth elements = Arrays.copyOf(elements, index + 1); } - elements[index] = requireNonNull(object); + elements[index] = requireNonNull(obj); + size++; return this; } @Override Collection> values() { - return new RegularAsCollection<>(elements); + return new RegularAsCollection<>(elements, size); } @Override int size() { - return countElements(elements); + return size; } - } - static int countElements(final Object[] elements) { - // Optimized for non-sparse case - int nulls = 0; - for (Object e : elements) { - if (e == null) { - nulls++; + @Override + StatementMap ensureCapacity(final int expectedLimit) { + if (elements.length < expectedLimit) { + elements = Arrays.copyOf(elements, expectedLimit); } + return this; } - return elements.length - nulls; + @Override + int capacity() { + return elements.length; + } } private static final class RegularAsCollection extends AbstractCollection { private final T[] elements; + private final int size; - RegularAsCollection(final T[] elements) { - this.elements = Preconditions.checkNotNull(elements); + RegularAsCollection(final T[] elements, final int size) { + this.elements = requireNonNull(elements); + this.size = size; } @Override @@ -125,12 +145,6 @@ abstract class StatementMap { } } - @Override - public boolean isEmpty() { - // This has a single-use and when it is instantiated, we know to have at least two items - return false; - } - @Override public Iterator iterator() { return new AbstractIterator() { @@ -152,7 +166,7 @@ abstract class StatementMap { @Override public int size() { - return countElements(elements); + return size; } } @@ -169,9 +183,9 @@ abstract class StatementMap { } @Override - StatementMap put(final int index, final StatementContextBase object) { + StatementMap put(final int index, final StatementContextBase obj) { checkArgument(index != 0); - return new Regular(this.object, index, object); + return new Regular(this.object, index, obj); } @Override @@ -183,6 +197,16 @@ abstract class StatementMap { int size() { return 1; } + + @Override + StatementMap ensureCapacity(final int expectedLimit) { + return expectedLimit < 2 ? this : new Regular(expectedLimit, 0, object); + } + + @Override + int capacity() { + return 1; + } } private static final StatementMap EMPTY = new Empty(); @@ -203,11 +227,11 @@ abstract class StatementMap { * Add a statement at specified index. * * @param index Element index, must be non-negative - * @param object Object to store + * @param obj Object to store * @return New statement map * @throws IllegalArgumentException if the index is already occupied */ - abstract @Nonnull StatementMap put(int index, @Nonnull StatementContextBase object); + 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 @@ -216,7 +240,11 @@ abstract class StatementMap { * * @return Read-only view of available statements. */ - abstract @Nonnull Collection> values(); + abstract @NonNull Collection> values(); abstract int size(); + + abstract @NonNull StatementMap ensureCapacity(int expectedLimit); + + abstract int capacity(); }