This fixes up the issues reported and flips enforcement to on.
Change-Id: I7e5b5c20a8b9f1ce3de42aac512ac3b31779821f
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
<propertyExpansion>checkstyle.violationSeverity=error</propertyExpansion>
</configuration>
</plugin>
+ <plugin>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-maven-plugin</artifactId>
+ <configuration>
+ <failOnError>true</failOnError>
+ </configuration>
+ </plugin>
</plugins>
</build>
</project>
import com.google.common.cache.LoadingCache;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
import java.util.Map.Entry;
import javassist.CannotCompileException;
import javassist.CtClass;
protected static final String SERIALIZE_METHOD_NAME = "serialize";
protected static final AugmentableDispatchSerializer AUGMENTABLE = new AugmentableDispatchSerializer();
- private static final Field FIELD_MODIFIERS;
+ private static final Field FIELD_MODIFIERS = getModifiersField();
private final LoadingCache<Class<?>, DataObjectSerializerImplementation> implementations;
private final CtClass[] serializeArguments;
private final JavassistUtils javassist;
private BindingRuntimeContext context;
- static {
+ private static Field getModifiersField() {
/*
* Cache reflection access to field modifiers field. We need this to set
* fix the static declared fields to final once we initialize them. If we
* cannot get access, that's fine, too.
*/
- Field field = null;
+ final Field field;
try {
field = Field.class.getDeclaredField("modifiers");
- field.setAccessible(true);
} catch (NoSuchFieldException | SecurityException e) {
- LOG.warn("Could not get Field modifiers field, serializers run at decreased efficiency", e);
+ LOG.warn("Could not get modifiers field, serializers run at decreased efficiency", e);
+ return null;
}
- FIELD_MODIFIERS = field;
+ try {
+ AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
+ field.setAccessible(true);
+ return null;
+ });
+ } catch (SecurityException e) {
+ LOG.warn("Could not get access to modifiers field, serializers run at decreased efficiency", e);
+ return null;
+ }
+
+ return field;
}
protected AbstractStreamWriterGenerator(final JavassistUtils utils) {
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableMap;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
private final SchemaRootCodecContext<?> root;
BindingCodecContext(final BindingRuntimeContext context, final BindingNormalizedNodeCodecRegistry registry) {
- this.context = Preconditions.checkNotNull(context, "Binding Runtime Context is required.");
+ this.context = requireNonNull(context, "Binding Runtime Context is required.");
this.root = SchemaRootCodecContext.create(this);
this.identityCodec = new IdentityCodec(context);
this.instanceIdentifierCodec = new InstanceIdentifierCodec(this);
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
@Override
DataContainerCodecContext<?,?> currentNode = root;
for (final InstanceIdentifier.PathArgument bindingArg : binding.getPathArguments()) {
currentNode = currentNode.bindingPathArgumentChild(bindingArg, builder);
- Preconditions.checkArgument(currentNode != null, "Supplied Instance Identifier %s is not valid.", binding);
+ checkArgument(currentNode != null, "Supplied Instance Identifier %s is not valid.", binding);
}
return currentNode;
}
ListNodeCodecContext<?> currentList = null;
for (final YangInstanceIdentifier.PathArgument domArg : dom.getPathArguments()) {
- Preconditions.checkArgument(currentNode instanceof DataContainerCodecContext<?,?>,
+ checkArgument(currentNode instanceof DataContainerCodecContext,
"Unexpected child of non-container node %s", currentNode);
- final DataContainerCodecContext<?,?> previous = (DataContainerCodecContext<?,?>) currentNode;
+ final DataContainerCodecContext<?,?> previous = (DataContainerCodecContext<?, ?>) currentNode;
final NodeCodecContext<?> nextNode = previous.yangPathArgumentChild(domArg);
/*
* Identifier as Item or IdentifiableItem
*/
if (currentList != null) {
- Preconditions.checkArgument(currentList == nextNode,
+ checkArgument(currentList == nextNode,
"List should be referenced two times in YANG Instance Identifier %s", dom);
// We entered list, so now we have all information to emit
// We do not add path argument for choice, since
// it is not supported by binding instance identifier.
currentNode = nextNode;
- } else if (nextNode instanceof DataContainerCodecContext<?,?>) {
+ } else if (nextNode instanceof DataContainerCodecContext) {
if (bindingArguments != null) {
- bindingArguments.add(((DataContainerCodecContext<?,?>) nextNode).getBindingPathArgument(domArg));
+ bindingArguments.add(((DataContainerCodecContext<?, ?>) nextNode).getBindingPathArgument(domArg));
}
currentNode = nextNode;
} else if (nextNode instanceof LeafNodeCodecContext) {
- LOG.debug("Instance identifier referencing a leaf is not representable (%s)", dom);
+ LOG.debug("Instance identifier referencing a leaf is not representable ({})", dom);
return null;
}
}
// Algorithm ended in list as whole representation
// we sill need to emit identifier for list
if (currentNode instanceof ChoiceNodeCodecContext) {
- LOG.debug("Instance identifier targeting a choice is not representable (%s)", dom);
+ LOG.debug("Instance identifier targeting a choice is not representable ({})", dom);
return null;
}
if (currentNode instanceof CaseNodeCodecContext) {
- LOG.debug("Instance identifier targeting a case is not representable (%s)", dom);
+ LOG.debug("Instance identifier targeting a case is not representable ({})", dom);
return null;
}
}
private Codec<Object, Object> getCodec(final Class<?> valueType, final DataSchemaNode schema) {
- Preconditions.checkArgument(schema instanceof TypedDataSchemaNode, "Unsupported leaf node type %s", schema);
-
+ checkArgument(schema instanceof TypedDataSchemaNode, "Unsupported leaf node type %s", schema);
return getCodec(valueType, ((TypedDataSchemaNode)schema).getType());
}
} else if (typeDef instanceof LeafrefTypeDefinition) {
final Entry<GeneratedType, WithStatus> typeWithSchema = context.getTypeWithSchema(valueType);
final WithStatus schema = typeWithSchema.getValue();
- Preconditions.checkState(schema instanceof TypeDefinition<?>);
+ checkState(schema instanceof TypeDefinition);
return getCodec(valueType, (TypeDefinition<?>) schema);
}
return ValueTypeCodec.getCodecFor(valueType, typeDef);
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.IOException;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
private volatile BindingCodecContext codecContext;
public BindingNormalizedNodeCodecRegistry(final DataObjectSerializerGenerator generator) {
- this.generator = Preconditions.checkNotNull(generator);
+ this.generator = requireNonNull(generator);
this.serializers = CacheBuilder.newBuilder().weakKeys().build(new GeneratorLoader());
}
}
@Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public ContainerNode toNormalizedNodeNotification(final Notification data) {
// FIXME: Should the cast to DataObject be necessary?
return serializeDataObject((DataObject) data,
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
return DataContainerCodecPrototype.from(childClass, childSchema.get(), factory());
}
- LOG.debug("Supplied class %s is not valid case in schema %s", childClass, getSchema());
+ LOG.debug("Supplied class {} is not valid case in schema {}", childClass, getSchema());
return null;
}
cazeProto = byYangCaseChild.get(arg);
}
- return childNonNull(cazeProto, arg,"Argument %s is not valid child of %s", arg, getSchema()).get()
+ return childNonNull(cazeProto, arg, "Argument %s is not valid child of %s", arg, getSchema()).get()
.yangPathArgumentChild(arg);
}
@SuppressWarnings("unchecked")
@Override
public D deserialize(final NormalizedNode<?, ?> data) {
- Preconditions.checkArgument(data instanceof ChoiceNode);
- final NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> casted =
- (NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>>) data;
+ checkArgument(data instanceof ChoiceNode);
+ final ChoiceNode casted = (ChoiceNode) data;
final NormalizedNode<?, ?> first = Iterables.getFirst(casted.getValue(), null);
if (first == null) {
@Override
public PathArgument deserializePathArgument(final YangInstanceIdentifier.PathArgument arg) {
- Preconditions.checkArgument(getDomPathArgument().equals(arg));
+ checkArgument(getDomPathArgument().equals(arg));
return null;
}
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSortedMap;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
}
}
+ @SuppressFBWarnings("RV_RETURN_VALUE_OF_PUTIFABSENT_IGNORED")
private void reloadAllAugmentations() {
for (final Entry<AugmentationIdentifier, Type> augment : possibleAugmentations.entrySet()) {
final DataContainerCodecPrototype<?> augProto = getAugmentationPrototype(augment.getValue());
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
@SuppressWarnings({ "rawtypes", "unchecked" })
LazyDataObject(final DataObjectCodecContext<D,?> ctx, final NormalizedNodeContainer data) {
- this.context = Preconditions.checkNotNull(ctx, "Context must not be null");
- this.data = Preconditions.checkNotNull(data, "Data must not be null");
+ this.context = requireNonNull(ctx, "Context must not be null");
+ this.data = requireNonNull(data, "Data must not be null");
}
@Override
Object cached = cachedData.get(method);
if (cached == null) {
final Object readedValue = context.getBindingChildValue(method, data);
- if (readedValue == null) {
- cached = NULL_VALUE;
- } else {
- cached = readedValue;
+ cached = readedValue == null ? NULL_VALUE : readedValue;
+
+ final Object raced = cachedData.putIfAbsent(method, cached);
+ if (raced != null) {
+ // Load/store raced, we should return the stored value
+ cached = raced;
}
- cachedData.putIfAbsent(method, cached);
}
return cached == NULL_VALUE ? null : cached;
@Override
public Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAugmentations(final Object obj) {
- Preconditions.checkArgument(this == Proxy.getInvocationHandler(obj),
+ checkArgument(this == Proxy.getInvocationHandler(obj),
"Supplied object is not associated with this proxy handler");
return getAugmentationsImpl();
}
private Object getAugmentationImpl(final Class<?> cls) {
- Preconditions.checkNotNull(cls, "Supplied augmentation must not be null.");
+ requireNonNull(cls, "Supplied augmentation must not be null.");
final ImmutableMap<Class<? extends Augmentation<?>>, Augmentation<?>> aug = cachedAugmentations;
if (aug != null) {
package org.opendaylight.mdsal.binding.dom.codec.impl;
import com.google.common.base.Preconditions;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.binding.Augmentation;
private static final long serialVersionUID = 1L;
+ @SuppressFBWarnings("SE_TRANSIENT_FIELD_NOT_RESTORED")
private final transient Class<?> bindingClass;
private MissingSchemaForClassException(final Class<?> clz) {
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkState;
+
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
final class NotificationCodecContext<D extends DataObject & Notification>
@Override
public D deserialize(final NormalizedNode<?, ?> data) {
- Preconditions.checkState(data instanceof ContainerNode);
- return createBindingProxy((NormalizedNodeContainer<?, ?, ?>) data);
+ checkState(data instanceof ContainerNode);
+ return createBindingProxy((ContainerNode) data);
}
@Override
return false;
}
final ContainerNode other = (ContainerNode) obj;
- return delegate().equals(obj);
+ return delegate().equals(other);
}
@Override
Code Review / mdsal.git / commitdiff