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.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
* data store type and the instance identifier of the root node.
*/
public final class DataTreeIdentifier<T extends DataObject> implements HierarchicalIdentifier<DataTreeIdentifier<?>> {
+ @Serial
private static final long serialVersionUID = 1L;
private final @NonNull InstanceIdentifier<T> rootIdentifier;
*/
package org.opendaylight.mdsal.binding.api;
+import java.io.Serial;
+
/**
* This exception indicates that given notification can not be processed by corresponding mechanism.
* More info can be provided in message.
* Expected use: {@link NotificationPublishService}
*/
public class NotificationRejectedException extends Exception {
+ @Serial
private static final long serialVersionUID = 1L;
public NotificationRejectedException(final String message) {
*/
package org.opendaylight.mdsal.binding.api;
+import java.io.Serial;
+
/**
* Exception thrown when an attempt is made to open a new transaction in a closed
* chain.
*/
public final class TransactionChainClosedException extends IllegalStateException {
+ @Serial
private static final long serialVersionUID = 1L;
public TransactionChainClosedException(final String message) {
package org.opendaylight.mdsal.binding.api.query;
import com.google.common.annotations.Beta;
+import java.io.Serial;
/**
* Exception reported when the proposed query has a structural problem. This may be either a mismatch with underlying
*/
@Beta
public class QueryStructureException extends IllegalStateException {
+ @Serial
private static final long serialVersionUID = 1L;
public QueryStructureException(final String message) {
package org.opendaylight.mdsal.binding.dom.codec.api;
import com.google.common.annotations.Beta;
+import java.io.Serial;
/**
* Thrown where incorrect nesting of data structures was detected and was caused by user. This typically indicates
*/
@Beta
public class IncorrectNestingException extends IllegalArgumentException {
+ @Serial
private static final long serialVersionUID = 1L;
public IncorrectNestingException(final String message) {
package org.opendaylight.mdsal.binding.dom.codec.api;
import com.google.common.annotations.Beta;
+import java.io.Serial;
/**
* Thrown when user schema for supplied binding class is available in present schema context, but
*/
@Beta
public class MissingClassInLoadingStrategyException extends MissingSchemaException {
+ @Serial
private static final long serialVersionUID = 1L;
public MissingClassInLoadingStrategyException(final String msg, final Throwable cause) {
package org.opendaylight.mdsal.binding.dom.codec.api;
import com.google.common.annotations.Beta;
+import java.io.Serial;
/**
* Thrown when codec was used with data which are not modeled and available in schema used by codec.
*/
@Beta
public class MissingSchemaException extends IllegalArgumentException {
+ @Serial
private static final long serialVersionUID = 1L;
public MissingSchemaException(final String msg) {
import com.google.common.annotations.Beta;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
/**
*/
@Beta
public final class MissingSchemaForClassException extends MissingSchemaException {
+ @Serial
private static final long serialVersionUID = 1L;
@SuppressFBWarnings(value = "SE_TRANSIENT_FIELD_NOT_RESTORED", justification = "Documented in API contract")
public MissingSchemaForClassException(final Class<?> clz) {
super(String.format("Schema is not available for %s", clz));
- this.bindingClass = requireNonNull(clz);
+ bindingClass = requireNonNull(clz);
}
public @Nullable Class<?> getBindingClass() {
*/
package org.opendaylight.mdsal.binding.java.api.generator;
+import java.io.Serial;
import java.io.Serializable;
import java.util.Comparator;
import org.opendaylight.mdsal.binding.model.api.TypeMember;
* @param <T> TypeMember type
*/
public class AlphabeticallyTypeMemberComparator<T extends TypeMember> implements Comparator<T>, Serializable {
+ @Serial
private static final long serialVersionUID = 1L;
@Override
package org.opendaylight.mdsal.binding.java.api.generator;
import com.google.common.annotations.Beta;
+import java.io.Serial;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
*/
@Beta
final class ByTypeMemberComparator<T extends TypeMember> implements Comparator<T>, Serializable {
+ @Serial
private static final long serialVersionUID = 1L;
/**
return member1.getName().compareTo(member2.getName());
}
+ @Serial
@SuppressWarnings("static-method")
private Object readResolve() {
return INSTANCE;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
+import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@NonNullByDefault
public abstract sealed class JavaTypeName implements Identifier, Immutable {
private static final class Primitive extends JavaTypeName {
+ @Serial
private static final long serialVersionUID = 1L;
Primitive(final String simpleName) {
}
private abstract static sealed class Reference extends JavaTypeName {
+ @Serial
private static final long serialVersionUID = 1L;
Reference(final String simpleName) {
}
private static final class TopLevel extends Reference {
+ @Serial
private static final long serialVersionUID = 1L;
private final String packageName;
@Override
public List<String> localNameComponents() {
- final List<String> ret = new ArrayList<>();
+ final var ret = new ArrayList<String>();
ret.add(simpleName());
return ret;
}
}
private static final class Nested extends Reference {
+ @Serial
private static final long serialVersionUID = 1L;
private final Reference immediatelyEnclosingClass;
}
private static final Logger LOG = LoggerFactory.getLogger(JavaTypeName.class);
+ @Serial
private static final long serialVersionUID = 1L;
private final String simpleName;
*/
package org.opendaylight.mdsal.binding.spec.util;
+import java.io.Serial;
import org.opendaylight.yangtools.yang.binding.Identifier;
public class NodeKey implements Identifier<Node> {
+ @Serial
private static final long serialVersionUID = 1L;
private final int id;
@Override
public boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- NodeKey other = (NodeKey) obj;
- if (id != other.id) {
- return false;
- }
- return true;
+ return this == obj || obj != null && getClass() == obj.getClass() && id == ((NodeKey) obj).id;
}
}
import com.google.common.collect.Iterables;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.ObjectStreamException;
+import java.io.Serial;
import java.io.Serializable;
import java.util.Collections;
import java.util.Iterator;
*/
public class InstanceIdentifier<T extends DataObject>
implements HierarchicalIdentifier<InstanceIdentifier<? extends DataObject>> {
+ @Serial
private static final long serialVersionUID = 3L;
/*
}
private abstract static class AbstractPathArgument<T extends DataObject> implements PathArgument, Serializable {
+ @Serial
private static final long serialVersionUID = 1L;
private final @NonNull Class<T> type;
* @param <T> Item type
*/
public static class Item<T extends DataObject> extends AbstractPathArgument<T> {
+ @Serial
private static final long serialVersionUID = 1L;
Item(final Class<T> type) {
*/
public static class IdentifiableItem<I extends Identifiable<T> & DataObject, T extends Identifier<I>>
extends AbstractPathArgument<I> {
+ @Serial
private static final long serialVersionUID = 1L;
private final @NonNull T key;
private static final class CaseItem<C extends ChoiceIn<?> & DataObject, T extends ChildOf<? super C>>
extends Item<T> {
+ @Serial
private static final long serialVersionUID = 1L;
private final Class<C> caseType;
private static final class CaseIdentifiableItem<C extends ChoiceIn<?> & DataObject,
T extends ChildOf<? super C> & Identifiable<K>, K extends Identifier<T>> extends IdentifiableItem<T, K> {
+ @Serial
private static final long serialVersionUID = 1L;
private final Class<C> caseType;
@NonNull InstanceIdentifier<T> build();
}
+ @Serial
private Object writeReplace() throws ObjectStreamException {
return new InstanceIdentifierV3<>(this);
}
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.ObjectStreamException;
+import java.io.Serial;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
class InstanceIdentifierV3<T extends DataObject> implements Externalizable {
+ @Serial
private static final long serialVersionUID = 3L;
private @Nullable Iterable<PathArgument> pathArguments;
pathArguments = ImmutableList.copyOf(args);
}
+ @Serial
Object readResolve() throws ObjectStreamException {
return new InstanceIdentifier<>(targetType, pathArguments, wildcarded, hash);
}
package org.opendaylight.yangtools.yang.binding;
import java.io.ObjectStreamException;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
/**
*/
public class KeyedInstanceIdentifier<T extends Identifiable<K> & DataObject, K extends Identifier<T>>
extends InstanceIdentifier<T> {
+ @Serial
private static final long serialVersionUID = 2L;
+
private final K key;
KeyedInstanceIdentifier(final Class<@NonNull T> type, final Iterable<PathArgument> pathArguments,
return key == null != (kii.key == null);
}
+ @Serial
private Object writeReplace() throws ObjectStreamException {
return new KeyedInstanceIdentifierV2<>(this);
}
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.ObjectStreamException;
+import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
final class KeyedInstanceIdentifierV2<T extends Identifiable<K> & DataObject, K extends Identifier<T>>
extends InstanceIdentifierV3<T> {
+ @Serial
private static final long serialVersionUID = 2L;
private @Nullable K key;
key = (K) in.readObject();
}
+ @Serial
@Override
Object readResolve() throws ObjectStreamException {
return new KeyedInstanceIdentifier<>(getTargetType(), getPathArguments(), isWildcarded(), getHash(), key);
*/
package org.opendaylight.yangtools.yang.binding.test.mock;
+import java.io.Serial;
import org.opendaylight.yangtools.yang.binding.Identifier;
public class NodeChildKey implements Identifier<NodeChild> {
+ @Serial
private static final long serialVersionUID = 1L;
private final int id;
@Override
public boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- NodeChildKey other = (NodeChildKey) obj;
- if (id != other.id) {
- return false;
- }
- return true;
+ return this == obj || obj != null && getClass() == obj.getClass() && id == ((NodeChildKey) obj).id;
}
}
*/
package org.opendaylight.yangtools.yang.binding.test.mock;
+import java.io.Serial;
import org.opendaylight.yangtools.yang.binding.Identifier;
public class NodeKey implements Identifier<Node> {
+ @Serial
private static final long serialVersionUID = 1L;
private final int id;
@Override
public boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- NodeKey other = (NodeKey) obj;
- if (id != other.id) {
- return false;
- }
- return true;
+ return this == obj || obj != null && getClass() == obj.getClass() && id == ((NodeKey) obj).id;
}
}
*/
package org.opendaylight.mdsal.common.api;
+import java.io.Serial;
+
/**
- * This exception occurs if the datastore is temporarily unavailable.
- * A retry of the transaction may succeed after a period of time
+ * This exception occurs if the datastore is temporarily unavailable. A retry of the transaction may succeed after
+ * a period of time.
*/
-
public class DataStoreUnavailableException extends Exception {
+ @Serial
private static final long serialVersionUID = 1L;
- public DataStoreUnavailableException(String message, Throwable cause) {
+ public DataStoreUnavailableException(final String message, final Throwable cause) {
super(message, cause);
}
-
-
}
import static java.util.Objects.requireNonNull;
+import java.io.Serial;
import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
* by this transaction is invalid.
*/
public class DataValidationFailedException extends TransactionCommitFailedException {
+ @Serial
private static final long serialVersionUID = 1L;
private final HierarchicalIdentifier<?> path;
*/
package org.opendaylight.mdsal.common.api;
+import java.io.Serial;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
* updated transaction.
*/
public class OptimisticLockFailedException extends TransactionCommitFailedException {
+ @Serial
private static final long serialVersionUID = 1L;
public OptimisticLockFailedException(final String message, final Throwable cause) {
*/
package org.opendaylight.mdsal.common.api;
+import java.io.Serial;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.RpcError;
* An exception for a failed read.
*/
public class ReadFailedException extends OperationFailedException {
+ @Serial
private static final long serialVersionUID = 1L;
public static final ExceptionMapper<ReadFailedException> MAPPER =
*/
package org.opendaylight.mdsal.common.api;
+import java.io.Serial;
import java.util.function.Supplier;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
* @author Thomas Pantelis
*/
public class TransactionCommitDeadlockException extends TransactionCommitFailedException {
+ @Serial
private static final long serialVersionUID = 1L;
private static final String DEADLOCK_MESSAGE = "An attempt to block on a ListenableFuture via a get method from a "
+ "write transaction submit was detected that would result in deadlock. The commit result must be obtained "
*/
package org.opendaylight.mdsal.common.api;
+import java.io.Serial;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.RpcError;
/**
- * Failed commit of asynchronous transaction.
- * This exception is raised and returned when transaction commit
- * failed.
- *
+ * Failed commit of asynchronous transaction. This exception is raised and returned when transaction commit failed.
*/
public class TransactionCommitFailedException extends OperationFailedException {
-
+ @Serial
private static final long serialVersionUID = 1L;
public TransactionCommitFailedException(final String message, final RpcError... errors) {
this(message, null, errors);
}
- public TransactionCommitFailedException(final String message, final Throwable cause,
- final RpcError... errors) {
+ public TransactionCommitFailedException(final String message, final Throwable cause, final RpcError... errors) {
super(message, cause, errors);
}
}
import com.google.common.collect.ImmutableList;
import com.google.common.io.Resources;
import java.io.IOException;
+import java.io.Serial;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
@NonNullByDefault
private static final class ScanningException extends Exception {
+ @Serial
private static final long serialVersionUID = 1L;
ScanningException(final Exception cause, final String format, final Object... args) {
import com.google.common.annotations.Beta;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.io.Serial;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
@Beta
@NonNullByDefault
public final class DefaultDOMRpcResult implements DOMRpcResult, Immutable, Serializable {
+ @Serial
private static final long serialVersionUID = 1L;
@SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "Interfaces do not specify Serializable")
import static org.mockito.Mockito.verify;
import com.google.common.base.MoreObjects;
+import java.io.Serial;
import java.util.Optional;
import org.junit.Assert;
import org.junit.Before;
}
private static final class TestException extends Exception {
+ @Serial
private static final long serialVersionUID = 1L;
}
}
\ No newline at end of file
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.eos.common.api.GenericEntity;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.core.general.entity.rev150930.EntityKey;
*/
@Beta
public class Entity extends GenericEntity<InstanceIdentifier<?>> {
+ @Serial
private static final long serialVersionUID = 1L;
/** Constructs an instance.
import static java.util.Objects.requireNonNull;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
* duplicate registration or two different components within the same process trying to register a Candidate.
*/
public class CandidateAlreadyRegisteredException extends Exception {
+ @Serial
private static final long serialVersionUID = 1L;
private final @NonNull GenericEntity<?> entity;
import static java.util.Objects.requireNonNull;
+import java.io.Serial;
import java.io.Serializable;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
* @param <T> the entity identifier type
*/
public class GenericEntity<T extends HierarchicalIdentifier<T>> implements Serializable, Identifiable<T> {
+ @Serial
private static final long serialVersionUID = 1L;
private final @NonNull String type;
if (obj == null || getClass() != obj.getClass()) {
return false;
}
- final GenericEntity<?> entity = (GenericEntity<?>) obj;
+ final var entity = (GenericEntity<?>) obj;
return id.equals(entity.id) && type.equals(entity.type);
}
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
+import java.io.Serial;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
}
private static final class TestClass implements HierarchicalIdentifier<TestClass> {
+ @Serial
private static final long serialVersionUID = 1L;
@Override
}
private static final class TestClassDiff implements HierarchicalIdentifier<TestClassDiff> {
+ @Serial
private static final long serialVersionUID = 1L;
@Override
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.eos.common.api.GenericEntity;
import org.opendaylight.yangtools.yang.common.QName;
*/
@Beta
public class DOMEntity extends GenericEntity<YangInstanceIdentifier> {
+ @Serial
private static final long serialVersionUID = 1L;
static final QName ENTITY = QName.create(
*/
package org.opendaylight.mdsal.replicate.netty;
+import java.io.Serial;
+
final class KeepaliveException extends Exception {
+ @Serial
private static final long serialVersionUID = 1L;
KeepaliveException(final int missedKeepalives) {
*/
package org.opendaylight.mdsal.singleton.common.api;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.AbstractStringIdentifier;
* Identifier represents a service group competence. It's based on String.
*/
public class ServiceGroupIdentifier extends AbstractStringIdentifier<ServiceGroupIdentifier> {
+ @Serial
private static final long serialVersionUID = 6853612584804702662L;
protected ServiceGroupIdentifier(final @NonNull String string) {
*/
package org.opendaylight.mdsal.singleton.dom.impl.util;
+import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.eos.common.api.GenericEntity;
import org.opendaylight.yangtools.yang.common.QName;
* Test util class.
*/
public class TestEntity extends GenericEntity<TestInstanceIdentifier> {
+ @Serial
private static final long serialVersionUID = 1L;
static final QName ENTITY = QName
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
+import java.io.Serial;
import java.util.LinkedList;
import java.util.List;
import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
* Test helper class. {@link HierarchicalIdentifier} for testing only.
*/
public class TestInstanceIdentifier implements HierarchicalIdentifier<TestInstanceIdentifier> {
+ @Serial
private static final long serialVersionUID = 1L;
private final ImmutableList<String> path;
public boolean contains(final TestInstanceIdentifier other) {
throw new UnsupportedOperationException();
}
-
}
Code Review / mdsal.git / commitdiff