}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public final boolean contains(final Object o) {
if (!(o instanceof Entry)) {
return false;
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public final boolean add(final K e) {
throw new UnsupportedOperationException();
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public final boolean addAll(final Collection<? extends K> c) {
throw new UnsupportedOperationException();
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public final boolean contains(final Object o) {
return map.containsKey(o);
}
private static <K, V> MainNode<K,V> dual(final SNode<K, V> x, final int xhc, final SNode<K, V> y, final int yhc,
final int lev, final Gen gen) {
if (lev >= HASH_BITS) {
- return new LNode<>(x.k, x.v, y.k, y.v);
+ return new LNode<>(x.key, x.value, y.key, y.value);
}
final int xidx = (xhc >>> lev) & 0x1f;
/**
* Utility implementing {@link Entry#equals(Object)}.
*/
- static boolean equal(final Object o, final Object key, final Object value) {
- if (!(o instanceof Entry)) {
+ static boolean equal(final Object obj, final Object key, final Object value) {
+ if (!(obj instanceof Entry)) {
return false;
}
- final Entry<?,?> e = (Entry<?,?>)o;
+ final Entry<?,?> e = (Entry<?,?>)obj;
return key.equals(e.getKey()) && value.equals(e.getValue());
}
return false;
} else if (cnAtPos instanceof SNode) {
final SNode<K, V> sn = (SNode<K, V>) cnAtPos;
- if (sn.hc == hc && ct.equal(sn.k, k)) {
+ if (sn.hc == hc && ct.equal(sn.key, k)) {
return GCAS(cn, cn.updatedAt(pos, new SNode<>(k, v, hc), gen), ct);
}
} else if (cnAtPos instanceof SNode) {
final SNode<K, V> sn = (SNode<K, V>) cnAtPos;
if (cond == null) {
- if (sn.hc == hc && ct.equal(sn.k, k)) {
+ if (sn.hc == hc && ct.equal(sn.key, k)) {
if (GCAS(cn, cn.updatedAt(pos, new SNode<>(k, v, hc), gen), ct)) {
- return Optional.of(sn.v);
+ return Optional.of(sn.value);
}
return null;
return insertDual(ct, cn, pos, sn, k, v, hc, lev);
} else if (cond == ABSENT) {
- if (sn.hc == hc && ct.equal(sn.k, k)) {
- return Optional.of(sn.v);
+ if (sn.hc == hc && ct.equal(sn.key, k)) {
+ return Optional.of(sn.value);
}
return insertDual(ct, cn, pos, sn, k, v, hc, lev);
} else if (cond == PRESENT) {
- if (sn.hc == hc && ct.equal(sn.k, k)) {
+ if (sn.hc == hc && ct.equal(sn.key, k)) {
if (GCAS(cn, cn.updatedAt(pos, new SNode<>(k, v, hc), gen), ct)) {
- return Optional.of(sn.v);
+ return Optional.of(sn.value);
}
return null;
}
return Optional.empty();
} else {
- if (sn.hc == hc && ct.equal(sn.k, k) && cond.equals(sn.v)) {
+ if (sn.hc == hc && ct.equal(sn.key, k) && cond.equals(sn.value)) {
if (GCAS(cn, cn.updatedAt(pos, new SNode<>(k, v, hc), gen), ct)) {
- return Optional.of(sn.v);
+ return Optional.of(sn.value);
}
return null;
} else if (sub instanceof SNode) {
// 2) singleton node
final SNode<K, V> sn = (SNode<K, V>) sub;
- if (sn.hc == hc && ct.equal(sn.k, k)) {
- return sn.v;
+ if (sn.hc == hc && ct.equal(sn.key, k)) {
+ return sn.value;
}
return null;
private Object cleanReadOnly(final TNode<K, V> tn, final int lev, final INode<K, V> parent,
final TrieMap<K, V> ct, final K k, final int hc) {
if (ct.isReadOnly()) {
- if (tn.hc == hc && ct.equal(tn.k, k)) {
- return tn.v;
+ if (tn.hc == hc && ct.equal(tn.key, k)) {
+ return tn.value;
}
return null;
}
} else if (sub instanceof SNode) {
final SNode<K, V> sn = (SNode<K, V>) sub;
- if (sn.hc == hc && ct.equal(sn.k, k) && (cond == null || cond.equals(sn.v))) {
+ if (sn.hc == hc && ct.equal(sn.key, k) && (cond == null || cond.equals(sn.value))) {
final MainNode<K, V> ncn = cn.removedAt(pos, flag, gen).toContracted(lev);
if (GCAS(cn, ncn, ct)) {
- res = Optional.of(sn.v);
+ res = Optional.of(sn.value);
} else {
res = null;
}
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean remove(final Object o) {
throw unsupported();
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean removeAll(final Collection<?> c) {
throw unsupported();
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean retainAll(final Collection<?> c) {
throw unsupported();
}
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean remove(final Object o) {
throw unsupported();
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean retainAll(final Collection<?> c) {
throw unsupported();
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean removeAll(final Collection<?> c) {
throw unsupported();
}
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public void putAll(final Map<? extends K, ? extends V> m) {
throw unsupported();
}
@SuppressFBWarnings(value = "EQ_UNUSUAL", justification = "Equality handled by utility methods")
@Override
- public final boolean equals(final Object o) {
- return EntryUtil.equal(o, key, value);
+ public final boolean equals(final Object obj) {
+ return EntryUtil.equal(obj, key, value);
}
@Override
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean add(final Entry<K, V> e) {
final K k = e.getKey();
checkArgument(k != null);
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean remove(final Object o) {
if (!(o instanceof Entry)) {
return false;
@SuppressFBWarnings(value = "EQ_UNUSUAL", justification = "Equality handled by utility methods")
@Override
- public boolean equals(final Object o) {
- return EntryUtil.equal(o, getKey(), getValue());
+ public boolean equals(final Object obj) {
+ return EntryUtil.equal(obj, getKey(), getValue());
}
@Override
}
@Override
+ @SuppressWarnings("checkstyle:parameterName")
public boolean remove(final Object o) {
return map().remove(o) != null;
}
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
final class SNode<K, V> extends BasicNode implements EntryNode<K, V> {
- final K k;
- final V v;
+ final K key;
+ final V value;
final int hc;
SNode(final K key, final V value, final int hc) {
- this.k = key;
- this.v = value;
+ this.key = key;
+ this.value = value;
this.hc = hc;
}
SNode<K, V> copy() {
- return new SNode<>(k, v, hc);
+ return new SNode<>(key, value, hc);
}
TNode<K, V> copyTombed() {
- return new TNode<>(k, v, hc);
+ return new TNode<>(key, value, hc);
}
SNode<K, V> copyUntombed() {
- return new SNode<>(k, v, hc);
+ return new SNode<>(key, value, hc);
}
@Override
@Override
public K getKey() {
- return k;
+ return key;
}
@Override
public V getValue() {
- return v;
+ return value;
}
@Override
public int hashCode() {
- return EntryUtil.hash(k, v);
+ return EntryUtil.hash(key, value);
}
@SuppressFBWarnings(value = "EQ_UNUSUAL", justification = "Equality handled by utility methods")
@Override
- public boolean equals(final Object o) {
- return EntryUtil.equal(o, k, v);
+ public boolean equals(final Object obj) {
+ return EntryUtil.equal(obj, key, value);
}
@Override
public String toString() {
- return EntryUtil.string(k, v);
+ return EntryUtil.string(key, value);
}
}
private TrieMap<Object, Object> map;
private boolean readOnly;
- @SuppressWarnings("checkStyle:redundantModifier")
+ @SuppressWarnings("checkstyle:redundantModifier")
public SerializationProxy() {
// For Externalizable
}
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
final class TNode<K, V> extends MainNode<K, V> implements EntryNode<K, V> {
- final K k;
- final V v;
+ final K key;
+ final V value;
final int hc;
TNode(final K key, final V value, final int hc) {
- this.k = key;
- this.v = value;
+ this.key = key;
+ this.value = value;
this.hc = hc;
}
TNode<K, V> copy() {
- return new TNode<>(k, v, hc);
+ return new TNode<>(key, value, hc);
}
TNode<K, V> copyTombed() {
- return new TNode<>(k, v, hc);
+ return new TNode<>(key, value, hc);
}
SNode<K, V> copyUntombed() {
- return new SNode<>(k, v, hc);
+ return new SNode<>(key, value, hc);
}
@Override
@Override
public K getKey() {
- return k;
+ return key;
}
@Override
public V getValue() {
- return v;
+ return value;
}
@Override
public int hashCode() {
- return EntryUtil.hash(k, v);
+ return EntryUtil.hash(key, value);
}
@SuppressFBWarnings(value = "EQ_UNUSUAL", justification = "Equality handled by utility methods")
@Override
- public boolean equals(final Object o) {
- return EntryUtil.equal(o, k, v);
+ public boolean equals(final Object obj) {
+ return EntryUtil.equal(obj, key, value);
}
@Override
public String toString() {
- return EntryUtil.string(k, v);
+ return EntryUtil.string(key, value);
}
}
Code Review / yangtools.git / commitdiff