import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Identifier;
* @param <T> Object type
*/
public abstract class AbstractIdentifier<T> implements Identifier {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull T value;
if (this == obj) {
return true;
}
- if (obj == null) {
- return false;
- }
-
- return getClass().equals(obj.getClass()) && value.equals(((AbstractIdentifier<?>)obj).value);
+ return obj != null && getClass().equals(obj.getClass()) && value.equals(((AbstractIdentifier<?>)obj).value);
}
@Override
*/
package org.opendaylight.yangtools.util;
-import java.io.Serial;
import java.util.UUID;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Identifier;
*/
public abstract class AbstractStringIdentifier<T extends AbstractStringIdentifier<T>>
extends AbstractIdentifier<String> implements Comparable<T> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
protected AbstractStringIdentifier(final @NonNull String string) {
*/
package org.opendaylight.yangtools.util;
-import java.io.Serial;
import java.util.UUID;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Identifier;
*/
public abstract class AbstractUUIDIdentifier<T extends AbstractUUIDIdentifier<T>> extends AbstractIdentifier<UUID>
implements Comparable<T> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
protected AbstractUUIDIdentifier(final @NonNull UUID uuid) {
import static java.util.Objects.requireNonNull;
import com.google.common.collect.UnmodifiableIterator;
-import java.io.Serial;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
* @param <E> the type of elements in this list
*/
final class ConstantArrayCollection<E> implements Collection<E>, Serializable {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final E @NonNull[] array;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
/**
* Base class for {@link ImmutableOffsetMap} serialization proxies. Implements most of the serialization form at logic.
*/
abstract sealed class IOMv1<T extends ImmutableOffsetMap<?, ?>> implements Externalizable permits OIOMv1, UIOMv1 {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1;
private ImmutableOffsetMap<?, ?> map;
abstract @NonNull T createInstance(@NonNull ImmutableList<Object> keys, @NonNull Object[] values);
- @Serial
+ @java.io.Serial
final Object readResolve() {
return verifyNotNull(map);
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.UnmodifiableIterator;
-import java.io.Serial;
import java.io.Serializable;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.AbstractSet;
*/
public abstract sealed class ImmutableOffsetMap<K, V> implements UnmodifiableMapPhase<K, V>, Serializable {
static final class Ordered<K, V> extends ImmutableOffsetMap<K, V> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
Ordered(final ImmutableMap<K, Integer> offsets, final V[] objects) {
}
static final class Unordered<K, V> extends ImmutableOffsetMap<K, V> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
Unordered(final ImmutableMap<K, Integer> offsets, final V[] objects) {
}
}
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull ImmutableMap<K, Integer> offsets;
}
}
- @Serial
+ @java.io.Serial
abstract Object writeReplace();
}
package org.opendaylight.yangtools.util;
import com.google.common.collect.ImmutableList;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.ImmutableOffsetMap.Ordered;
* Serialization proxy for {@link Ordered}.
*/
final class OIOMv1 extends IOMv1<Ordered<?, ?>> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1;
@SuppressWarnings("checkstyle:RedundantModifier")
*/
package org.opendaylight.yangtools.util;
-import java.io.Serial;
import java.io.Serializable;
/**
* Serialization proxy for {@link SingletonSet}.
*/
final class SSv1 implements Serializable {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1;
private final Object element;
this.element = element;
}
- @Serial
+ @java.io.Serial
private Object readResolve() {
return SingletonSet.of(element);
}
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
-import java.io.Serial;
import java.io.Serializable;
import java.util.AbstractMap.SimpleImmutableEntry;
-import java.util.Iterator;
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
*/
public abstract sealed class SharedSingletonMap<K, V> implements Serializable, UnmodifiableMapPhase<K, V> {
static final class Ordered<K, V> extends SharedSingletonMap<K, V> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
Ordered(final K key, final V value) {
}
static final class Unordered<K, V> extends SharedSingletonMap<K, V> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
Unordered(final K key, final V value) {
}
}
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private static final LoadingCache<Object, SingletonSet<Object>> CACHE = CacheBuilder.newBuilder().weakValues()
.build(new CacheLoader<Object, SingletonSet<Object>>() {
@Override
public final boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (!(obj instanceof Map)) {
- return false;
- }
-
- final Map<?, ?> m = (Map<?, ?>)obj;
- return m.size() == 1 && value.equals(m.get(keySet.getElement()));
+ return this == obj || obj instanceof Map<?, ?> other && other.size() == 1
+ && value.equals(other.get(keySet.getElement()));
}
@Override
}
private static <K, V> Entry<K, V> singleEntry(final Map<K, V> map) {
- final Iterator<Entry<K, V>> it = map.entrySet().iterator();
+ final var it = map.entrySet().iterator();
checkArgument(it.hasNext(), "Input map is empty");
- final Entry<K, V> ret = it.next();
+ final var ret = it.next();
checkArgument(!it.hasNext(), "Input map has more than one entry");
return ret;
}
import com.google.common.collect.Iterators;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.Serial;
import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
}
private static final class NullElement<E> extends SingletonSet<E> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
static final @NonNull NullElement<?> INSTANCE = new NullElement<>();
@NonNullByDefault
private static final class Regular<E> extends SingletonSet<E> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull E element;
package org.opendaylight.yangtools.util;
import com.google.common.collect.ImmutableList;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.ImmutableOffsetMap.Unordered;
* Serialization proxy for {@link Unordered}.
*/
final class UIOMv1 extends IOMv1<Unordered<?, ?>> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1;
@SuppressWarnings("checkstyle:RedundantModifier")
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.Serial;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
* threads are busy.
*/
private static class ExecutorQueue extends SynchronousQueue<Runnable> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private static final long POLL_WAIT_TIME_IN_MS = 300;
package org.opendaylight.yangtools.util.concurrent;
import com.google.common.annotations.Beta;
-import java.io.Serial;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.Collection;
* @param <E> the element t.ype
*/
public class TrackingLinkedBlockingQueue<E> extends LinkedBlockingQueue<E> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private static final VarHandle LARGEST_QUEUE_SIZE;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
final class DSIv1 implements Externalizable {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private QName qname;
qname = QName.readFrom(in);
}
- @Serial
+ @java.io.Serial
private Object readResolve() {
return DatastoreIdentifier.create(qname);
}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import java.util.Map.Entry;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
* Externalizable proxy for {@link NodeIdentifierWithPredicates}.
*/
final class NIPv2 implements Externalizable {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private NodeIdentifierWithPredicates nip;
};
}
- @Serial
+ @java.io.Serial
private Object readResolve() {
return nip;
}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
* Externalizable proxy for {@link NodeWithValue}.
*/
final class NIVv1 implements Externalizable {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private NodeWithValue<?> niv;
niv = new NodeWithValue<>(QName.readFrom(in), in.readObject());
}
- @Serial
+ @java.io.Serial
private Object readResolve() {
return niv;
}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
* Externalizable proxy for {@link NodeIdentifier}.
*/
final class NIv1 implements Externalizable {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private NodeIdentifier nid;
nid = new NodeIdentifier(QName.readFrom(in));
}
- @Serial
+ @java.io.Serial
private Object readResolve() {
return nid;
}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
* Externalizable proxy for {@link YangInstanceIdentifier}.
*/
final class YIDv1 implements Externalizable {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private YangInstanceIdentifier yid;
yid = YangInstanceIdentifier.of(builder.build());
}
- @Serial
+ @java.io.Serial
private Object readResolve() {
return yid;
}