... instead of Guava’s Preconditions.checkNotNull.
Change-Id: If7979ac0071e8c1d1af2d7913c6df791942825ab
Signed-off-by: Stephen Kitt <skitt@redhat.com>
*/
package org.opendaylight.mdsal.binding.maven.api.gen.plugin;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Joiner;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
import com.google.common.collect.Table;
}
private static void setOutputBaseDirAsSourceFolder(final File outputBaseDir, final MavenProject mavenProject) {
- Preconditions.checkNotNull(mavenProject, "Maven project needs to be set in this phase");
+ requireNonNull(mavenProject, "Maven project needs to be set in this phase");
mavenProject.addCompileSourceRoot(outputBaseDir.getPath());
}
@Override
public void setBuildContext(final BuildContext buildContext) {
- this.buildContext = Preconditions.checkNotNull(buildContext);
+ this.buildContext = requireNonNull(buildContext);
}
private Set<File> generateYangModuleInfo(final File outputBaseDir, final Module module, final SchemaContext ctx,
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Maps;
import java.util.ArrayList;
import java.util.Collection;
protected BindingDOMDataTreeListenerAdapter(final DataTreeListener delegate,
final BindingToNormalizedNodeCodec codec, final LogicalDatastoreType store) {
super(codec, delegate);
- this.store = Preconditions.checkNotNull(store, "store");
+ this.store = requireNonNull(store, "store");
}
@Override
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
BindingDataTreeChangeListenerRegistration(final L listener, final ListenerRegistration<?> domReg) {
super(listener);
- this.domReg = Preconditions.checkNotNull(domReg);
+ this.domReg = requireNonNull(domReg);
}
@Override
*/
package org.opendaylight.mdsal.binding.dom.adapter.invoke;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
private LocalNameRpcServiceInvoker(final QNameModule module, final Map<String, Method> map) {
super(map);
- this.module = Preconditions.checkNotNull(module);
+ this.module = requireNonNull(module);
}
static RpcServiceInvoker instanceFor(final QNameModule module, final Map<QName, Method> qnameToMethod) {
*/
package org.opendaylight.mdsal.binding.dom.codec.osgi.impl;
-import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
import com.google.common.io.Resources;
private volatile boolean starting = true;
ModuleInfoBundleTracker(final OsgiModuleInfoRegistry moduleInfoRegistry) {
- this.moduleInfoRegistry = checkNotNull(moduleInfoRegistry);
+ this.moduleInfoRegistry = requireNonNull(moduleInfoRegistry);
}
void finishStart() {
*/
package org.opendaylight.mdsal.binding.dom.codec.osgi.impl;
-import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.mdsal.binding.generator.api.ModuleInfoRegistry;
OsgiModuleInfoRegistry(final ModuleInfoRegistry moduleInfoRegistry,
final SchemaContextProvider schemaContextProvider, final SimpleBindingRuntimeContextService runtimeContext) {
- this.moduleInfoRegistry = checkNotNull(moduleInfoRegistry);
- this.schemaContextProvider = checkNotNull(schemaContextProvider);
- this.runtimeContext = checkNotNull(runtimeContext);
+ this.moduleInfoRegistry = requireNonNull(moduleInfoRegistry);
+ this.schemaContextProvider = requireNonNull(schemaContextProvider);
+ this.runtimeContext = requireNonNull(runtimeContext);
}
@SuppressWarnings("checkstyle:illegalCatch")
private final ObjectRegistration<YangModuleInfo> inner;
ObjectRegistrationWrapper(final ObjectRegistration<YangModuleInfo> inner) {
- this.inner = checkNotNull(inner);
+ this.inner = requireNonNull(inner);
}
@Override
*/
package org.opendaylight.mdsal.binding.dom.codec.osgi.impl;
-import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
import com.google.common.util.concurrent.ListenableFuture;
import javax.annotation.concurrent.GuardedBy;
SimpleBindingRuntimeContextService(final BundleContext context, final ClassLoadingStrategy strategy,
final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
super(context, BindingRuntimeContextListener.class, null);
- this.sourceProvider = checkNotNull(sourceProvider);
- this.strategy = checkNotNull(strategy);
+ this.sourceProvider = requireNonNull(sourceProvider);
+ this.strategy = requireNonNull(strategy);
}
@Override
package org.opendaylight.mdsal.binding.dom.codec.gen.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.mdsal.binding.dom.codec.util.BindingSchemaMapping;
DataNodeContainerSerializerSource(final AbstractGenerator generator, final GeneratedType type,
final DataNodeContainer node) {
super(generator);
- this.dtoType = Preconditions.checkNotNull(type);
- this.schemaNode = Preconditions.checkNotNull(node);
+ this.dtoType = requireNonNull(type);
+ this.schemaNode = requireNonNull(node);
}
/**
*/
package org.opendaylight.mdsal.binding.dom.codec.gen.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.mdsal.binding.dom.codec.gen.spi.AbstractSource;
import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy;
import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
* @param generator Parent generator
*/
DataObjectSerializerSource(final AbstractGenerator generator) {
- this.generator = Preconditions.checkNotNull(generator);
+ this.generator = requireNonNull(generator);
}
@SuppressWarnings("unchecked")
*/
package org.opendaylight.mdsal.binding.dom.codec.gen.spi;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
/**
* Definition of static property for generated class.
private final Object value;
public StaticConstantDefinition(final String name, final Class<?> type, final Object value) {
- this.name = Preconditions.checkNotNull(name);
- this.type = Preconditions.checkNotNull(type);
- this.value = Preconditions.checkNotNull(value);
+ this.name = requireNonNull(name);
+ this.type = requireNonNull(type);
+ this.value = requireNonNull(value);
}
public String getName() {
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
BindingNormalizedNodeCache(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
final DataContainerCodecContext<?, ?> subtreeRoot) {
- this.cacheHolder = Preconditions.checkNotNull(cacheHolder, "cacheHolder");
- this.subtreeRoot = Preconditions.checkNotNull(subtreeRoot, "subtreeRoot");
+ this.cacheHolder = requireNonNull(cacheHolder, "cacheHolder");
+ this.subtreeRoot = requireNonNull(subtreeRoot, "subtreeRoot");
}
@Override
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.util.AbstractMap;
BindingToNormalizedStreamWriter(final NodeCodecContext<?> rootNodeSchema,
final NormalizedNodeStreamWriter delegate) {
- this.rootNodeSchema = Preconditions.checkNotNull(rootNodeSchema);
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.rootNodeSchema = requireNonNull(rootNodeSchema);
+ this.delegate = requireNonNull(delegate);
}
static BindingToNormalizedStreamWriter create(final NodeCodecContext<?> schema,
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Throwables;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
private EncapsulatedValueCodec(final Class<?> typeClz, final MethodHandle constructor, final MethodHandle getter,
final Class<?> valueType) {
super(typeClz);
- this.constructor = Preconditions.checkNotNull(constructor);
- this.getter = Preconditions.checkNotNull(getter);
- this.valueType = Preconditions.checkNotNull(valueType);
+ this.constructor = requireNonNull(constructor);
+ this.getter = requireNonNull(getter);
+ this.valueType = requireNonNull(valueType);
}
static Callable<EncapsulatedValueCodec> loader(final Class<?> typeClz, TypeDefinition<?> typeDef) {
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
private final BindingRuntimeContext context;
IdentityCodec(final BindingRuntimeContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
}
@Override
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Iterables;
import java.util.ArrayList;
import java.util.List;
private final BindingCodecContext context;
InstanceIdentifierCodec(final BindingCodecContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
}
@Override
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.binding.Augmentation;
private MissingSchemaForClassException(final Class<?> clz) {
super(String.format("Schema is not available for %s", clz));
- this.bindingClass = Preconditions.checkNotNull(clz);
+ this.bindingClass = requireNonNull(clz);
}
static MissingSchemaForClassException forClass(final Class<?> clz) {
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
abstract class ReflectionBasedCodec extends ValueTypeCodec {
private final Class<?> typeClass;
ReflectionBasedCodec(final Class<?> typeClass) {
- this.typeClass = Preconditions.checkNotNull(typeClass);
+ this.typeClass = requireNonNull(typeClass);
}
protected final Class<?> getTypeClass() {
package org.opendaylight.mdsal.binding.dom.codec.impl;
import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
import com.google.common.base.Throwables;
import com.google.common.base.Verify;
private ActionCodecContext prepareActionContext(final int inputOffset, final int outputOffset,
final int expectedArgsLength, final Class<? extends Action<?, ?, ?>> action, final Class<?> actionType) {
- final ParameterizedType paramType = checkNotNull(ClassLoaderUtils.findParameterizedType(action, actionType),
- "There does not exist any ParameterType in %s", action);
+ final ParameterizedType paramType = requireNonNull(ClassLoaderUtils.findParameterizedType(action, actionType),
+ () -> "There does not exist any ParameterType in " + action);
final Type[] args = paramType.getActualTypeArguments();
checkArgument(args.length == expectedArgsLength, "Unexpected (%s) Action generatic arguments", args.length);
final ActionDefinition schema = factory().getRuntimeContext().getActionDefinition(action);
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Throwables;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
UnionValueOptionContext(final Class<?> unionType, final Class<?> valueType, final Method getter,
final Codec<Object, Object> codec) {
- this.bindingType = Preconditions.checkNotNull(valueType);
- this.codec = Preconditions.checkNotNull(codec);
+ this.bindingType = requireNonNull(valueType);
+ this.codec = requireNonNull(codec);
try {
this.getter = MethodHandles.publicLookup().unreflect(getter).asType(OBJECT_TYPE);
*/
package org.opendaylight.mdsal.binding.dom.codec.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
import org.opendaylight.yangtools.yang.binding.DataContainer;
@SuppressWarnings("rawtypes")
private ChoiceDispatchSerializer(final Class choiceClass) {
- this.choiceClass = Preconditions.checkNotNull(choiceClass);
+ this.choiceClass = requireNonNull(choiceClass);
}
public static ChoiceDispatchSerializer from(final Class<? extends DataContainer> choiceClass) {
*/
package org.opendaylight.mdsal.binding.dom.codec.test;
+import static java.util.Objects.requireNonNull;
import static org.junit.Assert.assertNotNull;
-import com.google.common.base.Preconditions;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Set;
}
protected ClassExcludingClassLoadingStrategy(final GeneratedClassLoadingStrategy delegate) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
}
@Override
*/
package org.opendaylight.mdsal.binding.generator.util;
-import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
import com.google.common.base.Preconditions;
import java.net.URI;
}
public static QName getAugmentationQName(final AugmentationSchemaNode augmentation) {
- checkNotNull(augmentation, "Augmentation must not be null.");
+ requireNonNull(augmentation, "Augmentation must not be null.");
final QName identifier = getAugmentationIdentifier(augmentation);
if (identifier != null) {
return identifier;
*/
private GeneratedTransferObject wrapJavaTypeIntoTO(final String basePackageName, final TypeDefinition<?> typedef,
final Type javaType, final String moduleName) {
- Preconditions.checkNotNull(javaType, "javaType cannot be null");
+ requireNonNull(javaType, "javaType cannot be null");
final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef, moduleName);
genTOBuilder.setRestrictions(BindingGeneratorUtil.getRestrictions(typedef));
*/
public List<GeneratedTOBuilder> provideGeneratedTOBuildersForUnionTypeDef(final JavaTypeName typeName,
final UnionTypeDefinition typedef, final SchemaNode parentNode) {
- Preconditions.checkNotNull(typedef, "Type Definition cannot be NULL!");
- Preconditions.checkNotNull(typedef.getQName(), "Type definition QName cannot be NULL!");
+ requireNonNull(typedef, "Type Definition cannot be NULL!");
+ requireNonNull(typedef.getQName(), "Type definition QName cannot be NULL!");
final List<GeneratedTOBuilder> generatedTOBuilders = new ArrayList<>();
final List<TypeDefinition<?>> unionTypes = typedef.getTypes();
final TypeDefinition<?> type = CompatUtils.compatLeafType(node);
final QName typeQName = type.getQName();
final TypeDefinition<?> base = baseTypeDefForExtendedType(type);
- Preconditions.checkNotNull(type, "Cannot provide default construction for null type of %s", node);
- Preconditions.checkNotNull(defaultValue, "Cannot provide default construction for null default statement of %s",
- node);
+ requireNonNull(type, () -> "Cannot provide default construction for null type of " + node);
+ requireNonNull(defaultValue, () -> "Cannot provide default construction for null default statement of "
+ + node);
final StringBuilder sb = new StringBuilder();
String result = null;
*/
package org.opendaylight.mdsal.binding.generator.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.File;
import java.net.URISyntaxException;
import java.net.URL;
@Before
public void loadTestResources() throws URISyntaxException {
File testSourcesDir = new File(testSourcesDirUrl.toURI());
- File[] testFiles = Preconditions.checkNotNull(testSourcesDir.listFiles(), testSourcesDir
- + " does not denote a directory");
+ File[] testFiles = requireNonNull(testSourcesDir.listFiles(), testSourcesDir + " does not denote a directory");
testModels = new HashSet<>();
for (File file : testFiles) {
if (file.isFile()) {
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import java.io.File;
* @param types set of types for which JAVA code should be generated
*/
public GeneratorJavaFile(final Collection<? extends Type> types) {
- this.types = Preconditions.checkNotNull(types);
+ this.types = requireNonNull(types);
generators.add(new InterfaceGenerator());
generators.add(new TOGenerator());
generators.add(new EnumGenerator());
*/
package org.opendaylight.mdsal.binding.spec.reflect;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
private final T template;
private StringValueObjectFactory(final T template, final MethodHandle constructor, final MethodHandle setter) {
- this.template = Preconditions.checkNotNull(template);
+ this.template = requireNonNull(template);
this.constructor = constructor.bindTo(template);
- this.setter = Preconditions.checkNotNull(setter);
+ this.setter = requireNonNull(setter);
}
public static <T> StringValueObjectFactory<T> create(final Class<T> clazz, final String templateString) {
@SuppressWarnings("checkstyle:illegalCatch")
public T newInstance(final String string) {
- Preconditions.checkNotNull(string, "Argument may not be null");
+ requireNonNull(string, "Argument may not be null");
try {
final T ret = (T) constructor.invokeExact();
*/
package org.opendaylight.mdsal.binding.testutils;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
-import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
@Override
public void failReads(ReadFailedException exception) {
unfailReads();
- readException = Objects.requireNonNull(exception, "exception == null");
+ readException = requireNonNull(exception, "exception == null");
}
@Override
public void failReads(int howManyTimes, ReadFailedException exception) {
unfailReads();
howManyFailingReads.set(howManyTimes);
- readException = Objects.requireNonNull(exception, "exception == null");
+ readException = requireNonNull(exception, "exception == null");
}
@Override
public void failCommits(TransactionCommitFailedException exception) {
unfailCommits();
- this.commitException = Objects.requireNonNull(exception, "exception == null");
+ this.commitException = requireNonNull(exception, "exception == null");
}
@Override
public void failCommits(int howManyTimes, TransactionCommitFailedException exception) {
howManyFailingCommits.set(howManyTimes);
- this.commitException = Objects.requireNonNull(exception, "exception == null");
+ this.commitException = requireNonNull(exception, "exception == null");
}
@Override
package org.opendaylight.mdsal.binding.javav2.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.io.Serializable;
import java.util.Objects;
import javax.annotation.Nonnull;
private final LogicalDatastoreType datastoreType;
private DataTreeIdentifier(final LogicalDatastoreType datastoreType, final InstanceIdentifier<T> rootIdentifier) {
- this.datastoreType = Preconditions.checkNotNull(datastoreType);
- this.rootIdentifier = Preconditions.checkNotNull(rootIdentifier);
+ this.datastoreType = requireNonNull(datastoreType);
+ this.rootIdentifier = requireNonNull(rootIdentifier);
}
public static <T extends TreeNode> DataTreeIdentifier<T> create(final LogicalDatastoreType datastoreType,
package org.opendaylight.mdsal.binding.javav2.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
private static final long serialVersionUID = 1L;
public DataTreeListeningException(@Nonnull String message, @Nullable Throwable cause) {
- super(Preconditions.checkNotNull(message, "message"), cause);
+ super(requireNonNull(message, "message"), cause);
}
public DataTreeListeningException(@Nonnull String message) {
- super(Preconditions.checkNotNull(message, "message"));
+ super(requireNonNull(message, "message"));
}
}
package org.opendaylight.mdsal.binding.javav2.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import javax.annotation.Nonnull;
/**
public DataTreeProducerBusyException(@Nonnull final String message, @Nonnull final Throwable cause) {
- super(Preconditions.checkNotNull(message, "message"), cause);
+ super(requireNonNull(message, "message"), cause);
}
public DataTreeProducerBusyException(@Nonnull final String message) {
- super(Preconditions.checkNotNull(message, "message"));
+ super(requireNonNull(message, "message"));
}
}
\ No newline at end of file
*/
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.data.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Collection;
public BindingDOMDataTreeCommitCohortAdapter(final BindingToNormalizedNodeCodec codec,
final DataTreeCommitCohort<T> cohort) {
- this.codec = Preconditions.checkNotNull(codec);
- this.cohort = Preconditions.checkNotNull(cohort);
+ this.codec = requireNonNull(codec);
+ this.cohort = requireNonNull(cohort);
}
@Nonnull
*/
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.data.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.api.DataTreeCommitCohort;
import org.opendaylight.mdsal.binding.javav2.api.DataTreeCommitCohortRegistry;
private BindingDOMDataTreeCommitCohortRegistryAdapter(final BindingToNormalizedNodeCodec codec,
final DOMDataTreeCommitCohortRegistry registry) {
- this.codec = Preconditions.checkNotNull(codec);
- this.registry = Preconditions.checkNotNull(registry);
+ this.codec = requireNonNull(codec);
+ this.registry = requireNonNull(registry);
}
/**
*/
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.data.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import java.util.ArrayList;
import java.util.Collection;
public BindingDOMDataTreeListenerAdapter(final DataTreeListener delegate,
final BindingToNormalizedNodeCodec codec, final LogicalDatastoreType store) {
- this.delegate = Preconditions.checkNotNull(delegate, "delegate");
- this.codec = Preconditions.checkNotNull(codec, "codec");
- this.store = Preconditions.checkNotNull(store, "store");
+ this.delegate = requireNonNull(delegate, "delegate");
+ this.codec = requireNonNull(codec, "codec");
+ this.store = requireNonNull(store, "store");
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.data.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.api.CursorAwareWriteTransaction;
private BindingDOMDataTreeProducerAdapter(final DOMDataTreeProducer delegate,
final BindingToNormalizedNodeCodec codec) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
this.codec = codec;
}
*/
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.data.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.api.DataTreeIdentifier;
private BindingDOMDataTreeServiceAdapter(final DOMDataTreeService delegate,
final BindingToNormalizedNodeCodec codec) {
- this.delegate = Preconditions.checkNotNull(delegate, "delegate");
- this.codec = Preconditions.checkNotNull(codec, "codec");
+ this.delegate = requireNonNull(delegate, "delegate");
+ this.codec = requireNonNull(codec, "codec");
}
/**
*/
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.notification;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
@SuppressWarnings("checkstyle:IllegalCatch")
public void invokeNotification(@Nonnull final NotificationListener impl, @Nonnull final QName notificationName,
@Nullable final Instantiable<?> input) {
- Preconditions.checkNotNull(impl, "implementation must be supplied");
+ requireNonNull(impl, "implementation must be supplied");
final MethodHandle invoker = methodInvokers.get(notificationName);
Preconditions.checkArgument(invoker != null, "Supplied notification is not valid for implementation %s", impl);
try {
RpcServiceAdapter(final Class<? extends Rpc<?, ?>> type, final BindingToNormalizedNodeCodec codec,
final DOMRpcService domService) {
- this.type = Preconditions.checkNotNull(type);
- this.codec = Preconditions.checkNotNull(codec);
- this.delegate = Preconditions.checkNotNull(domService);
+ this.type = requireNonNull(type);
+ this.codec = requireNonNull(codec);
+ this.delegate = requireNonNull(domService);
strategy = createStrategy(type);
proxy = (Rpc<?, ?>) Proxy.newProxyInstance(type.getClassLoader(), new Class[] { type }, this);
}
*/
package org.opendaylight.mdsal.binding.javav2.dom.adapter.registration;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.binding.javav2.api.DataTreeListener;
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
public BindingDataTreeListenerRegistration(final L listener, final ListenerRegistration<?> domReg) {
super(listener);
- this.domReg = Preconditions.checkNotNull(domReg);
+ this.domReg = requireNonNull(domReg);
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.generator.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
/**
* Definition of static property for Binding objects.
private final Object value;
public StaticBindingProperty(final String name, final Class<?> type, final Object value) {
- this.name = Preconditions.checkNotNull(name);
- this.type = Preconditions.checkNotNull(type);
- this.value = Preconditions.checkNotNull(value);
+ this.name = requireNonNull(name);
+ this.type = requireNonNull(type);
+ this.value = requireNonNull(value);
}
public String getName() {
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.generator.spi.generator;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
}
protected AbstractStreamWriterGenerator(final JavassistUtils utils) {
- this.javassist = Preconditions.checkNotNull(utils, "JavassistUtils instance is required.");
+ this.javassist = requireNonNull(utils, "JavassistUtils instance is required.");
this.serializeArguments = new CtClass[] { javassist.asCtClass(TreeNodeSerializerRegistry.class),
javassist.asCtClass(TreeNode.class), javassist.asCtClass(BindingStreamEventWriter.class), };
javassist.appendClassLoaderIfMissing(TreeNodeSerializerPrototype.class.getClassLoader());
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.generator.spi.source;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collection;
import org.opendaylight.mdsal.binding.javav2.dom.codec.generator.spi.generator.AbstractGenerator;
final Collection<AugmentationSchemaNode> augmentationSchemas) {
// Note: passing first augmentation schema node just to avoid exceptions from super class.
super(generator, type, augmentationSchemas.stream().findFirst().get());
- this.augmentationSchemas = Preconditions.checkNotNull(augmentationSchemas);
+ this.augmentationSchemas = requireNonNull(augmentationSchemas);
}
/**
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.generator.spi.source;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public AbstractDataNodeContainerSerializerSource(final AbstractGenerator generator, final GeneratedType type,
final DataNodeContainer node) {
super(generator);
- this.dtoType = Preconditions.checkNotNull(type);
- this.schemaNode = Preconditions.checkNotNull(node);
+ this.dtoType = requireNonNull(type);
+ this.schemaNode = requireNonNull(node);
}
/**
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.generator.spi.source;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.binding.javav2.dom.codec.generator.spi.generator.AbstractGenerator;
import org.opendaylight.mdsal.binding.javav2.dom.codec.generator.spi.generator.AbstractStreamWriterGenerator;
import org.opendaylight.mdsal.binding.javav2.generator.api.ClassLoadingStrategy;
* -parent generator
*/
AbstractTreeNodeSerializerSource(final AbstractGenerator generator) {
- this.generator = Preconditions.checkNotNull(generator);
+ this.generator = requireNonNull(generator);
}
@SuppressWarnings("unchecked")
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import javax.xml.transform.dom.DOMSource;
* - binding runtime context
*/
public AnyxmlCodec(final BindingRuntimeContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
* - serializer generator
*/
public BindingNormalizedNodeCodecRegistry(final TreeNodeSerializerGenerator generator) {
- this.generator = Preconditions.checkNotNull(generator);
+ this.generator = requireNonNull(generator);
this.serializers = CacheBuilder.newBuilder().weakKeys().build(new GeneratorLoader());
}
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl;
import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
*/
public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy,
final BindingNormalizedNodeCodecRegistry codecRegistry, final boolean waitForSchema) {
- this.classLoadingStrategy = Preconditions.checkNotNull(classLoadingStrategy, "classLoadingStrategy");
- this.codecRegistry = Preconditions.checkNotNull(codecRegistry, "codecRegistry");
+ this.classLoadingStrategy = requireNonNull(classLoadingStrategy, "classLoadingStrategy");
+ this.codecRegistry = requireNonNull(codecRegistry, "codecRegistry");
this.futureSchema = waitForSchema ? new FutureSchema(WAIT_DURATION_SEC, TimeUnit.SECONDS) : null;
}
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.binding.javav2.runtime.context.BindingRuntimeContext;
* - binding runtime context
*/
public IdentityCodec(final BindingRuntimeContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import java.util.ArrayList;
import java.util.List;
* - binding codec context
*/
public InstanceIdentifierCodec(final BindingCodecContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.cache;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
});
protected AbstractBindingNormalizedNodeCacheHolder(@Nonnull final Set<Class<? extends TreeNode>> cacheSpec) {
- cachedValues = Preconditions.checkNotNull(cacheSpec);
+ cachedValues = requireNonNull(cacheSpec);
}
public BindingNormalizedNodeCache getCachingSerializer(final DataContainerCodecContext<?, ?> childCtx) {
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.cache;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
public BindingNormalizedNodeCache(@Nonnull final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
@Nonnull final DataContainerCodecContext<?, ?> subtreeRoot) {
- this.cacheHolder = Preconditions.checkNotNull(cacheHolder, "cacheHolder");
- this.subtreeRoot = Preconditions.checkNotNull(subtreeRoot, "subtreeRoot");
+ this.cacheHolder = requireNonNull(cacheHolder, "cacheHolder");
+ this.subtreeRoot = requireNonNull(subtreeRoot, "subtreeRoot");
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.cache;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.dom.codec.api.BindingNormalizedNodeCachingCodec;
public CachingNormalizedNodeCodec(final DataContainerCodecContext<D, ?> subtreeRoot,
final Set<Class<? extends TreeNode>> cacheSpec) {
super(cacheSpec);
- this.context = Preconditions.checkNotNull(subtreeRoot);
+ this.context = requireNonNull(subtreeRoot);
}
@Nonnull
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
* @return operation schema or null, if operation is not present in schema context.
*/
private ContainerSchemaNode getOperationDataSchema(final SchemaContext schema, final SchemaPath path) {
- Preconditions.checkNotNull(schema, "Schema context must not be null.");
- Preconditions.checkNotNull(path, "Schema path must not be null.");
+ requireNonNull(schema, "Schema context must not be null.");
+ requireNonNull(path, "Schema path must not be null.");
final Iterator<QName> it = path.getPathFromRoot().iterator();
Preconditions.checkArgument(it.hasNext(), "Operation must have QName.");
final QName operationName = it.next();
}
private ContainerSchemaNode getOperationDataSchema(final OperationDefinition operation, final QName qname) {
- Preconditions.checkNotNull(operation, "Operation Schema must not be null.");
- Preconditions.checkNotNull(qname, "QName must not be null.");
+ requireNonNull(operation, "Operation Schema must not be null.");
+ requireNonNull(qname, "QName must not be null.");
switch (qname.getLocalName()) {
case "input":
return operation.getInput();
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
*/
public UnionValueOptionContext(final Class<?> unionType, final Class<?> valueType, final Method getter,
final Codec<Object, Object> codec) {
- this.bindingType = Preconditions.checkNotNull(valueType);
- this.codec = Preconditions.checkNotNull(codec);
+ this.bindingType = requireNonNull(valueType);
+ this.codec = requireNonNull(codec);
try {
this.getter = MethodHandles.publicLookup().unreflect(getter).asType(OBJECT_TYPE);
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
AnyxmlNodeCodecContext(final DataSchemaNode schema, final Codec<Object, Object> codec, final Method getter,
final SchemaContext schemaContext) {
this.yangIdentifier = new YangInstanceIdentifier.NodeIdentifier(schema.getQName());
- this.valueCodec = Preconditions.checkNotNull(codec);
- this.getter = Preconditions.checkNotNull(getter);
- this.schema = Preconditions.checkNotNull(schema);
+ this.valueCodec = requireNonNull(codec);
+ this.getter = requireNonNull(getter);
+ this.schema = requireNonNull(schema);
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
* - binding normalized node codec registry
*/
public 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.anyxmlCodec = new AnyxmlCodec(context);
this.instanceIdentifierCodec = new InstanceIdentifierCodec(this);
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
@Override
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
@SuppressWarnings({"rawtypes", "unchecked"})
private DataContainerCodecPrototype(final Class<?> cls, final YangInstanceIdentifier.PathArgument arg,
final T nodeSchema, final CodecContextFactory factory) {
- this.bindingClass = Preconditions.checkNotNull(cls);
- this.yangArg = Preconditions.checkNotNull(arg);
- this.schema = Preconditions.checkNotNull(nodeSchema);
- this.factory = Preconditions.checkNotNull(factory);
+ this.bindingClass = requireNonNull(cls);
+ this.yangArg = requireNonNull(arg);
+ this.schema = requireNonNull(nodeSchema);
+ this.factory = requireNonNull(factory);
this.bindingArg = new Item(bindingClass);
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
@SuppressWarnings({ "rawtypes", "unchecked" })
LazyTreeNode(final TreeNodeCodecContext<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
if (aug != null) {
return aug.get(cls);
}
- Preconditions.checkNotNull(cls,"Supplied augmentation must not be null.");
+ requireNonNull(cls,"Supplied augmentation must not be null.");
@SuppressWarnings({"unchecked","rawtypes"})
final Optional<DataContainerCodecContext<?,?>> augCtx = context.possibleStreamChild((Class) cls);
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
LeafNodeCodecContext(final DataSchemaNode schema, final Codec<Object, Object> codec, final Method getter,
final SchemaContext schemaContext) {
this.yangIdentifier = new YangInstanceIdentifier.NodeIdentifier(schema.getQName());
- this.valueCodec = Preconditions.checkNotNull(codec);
- this.getter = Preconditions.checkNotNull(getter);
- this.schema = Preconditions.checkNotNull(schema);
+ this.valueCodec = requireNonNull(codec);
+ this.getter = requireNonNull(getter);
+ this.schema = requireNonNull(schema);
this.defaultObject = createDefaultObject(schema, valueCodec, schemaContext);
}
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.MissingSchemaException;
import org.opendaylight.mdsal.binding.javav2.runtime.context.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentation;
private MissingSchemaForClassException(final Class<?> clz) {
super(String.format("Schema is not available for %s", clz));
- this.bindingClass = Preconditions.checkNotNull(clz);
+ this.bindingClass = requireNonNull(clz);
}
static MissingSchemaForClassException forClass(final Class<?> clz) {
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.serializer;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import java.io.IOException;
private BindingToNormalizedStreamWriter(final NodeCodecContext<?> rootNodeSchema,
final NormalizedNodeStreamWriter delegate) {
- this.rootNodeSchema = Preconditions.checkNotNull(rootNodeSchema);
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.rootNodeSchema = requireNonNull(rootNodeSchema);
+ this.delegate = requireNonNull(delegate);
}
/**
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.serializer;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.io.IOException;
import org.opendaylight.mdsal.binding.javav2.spec.base.Instantiable;
import org.opendaylight.mdsal.binding.javav2.spec.base.Item;
@SuppressWarnings("rawtypes")
private ChoiceDispatchSerializer(final Class choiceClass) {
- this.choiceClass = Preconditions.checkNotNull(choiceClass);
+ this.choiceClass = requireNonNull(choiceClass);
}
/**
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.value;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
final Map<String, Method> getters) {
super(typeClass);
- this.ctor = Preconditions.checkNotNull(ctor);
+ this.ctor = requireNonNull(ctor);
this.ctorArgs = ImmutableSet.copyOf(ctorArgs);
this.getters = ImmutableMap.copyOf(getters);
}
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.value;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
final Class<?> valueType) {
super(typeClz);
- this.constructor = Preconditions.checkNotNull(constructor);
- this.getter = Preconditions.checkNotNull(getter);
- this.valueType = Preconditions.checkNotNull(valueType);
+ this.constructor = requireNonNull(constructor);
+ this.getter = requireNonNull(getter);
+ this.valueType = requireNonNull(valueType);
}
static Callable<EncapsulatedValueCodec> loader(final Class<?> typeClz, final TypeDefinition<?> typeDef) {
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.value;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
@Beta
public abstract class ReflectionBasedCodec extends ValueTypeCodec {
private final Class<?> typeClass;
protected ReflectionBasedCodec(final Class<?> typeClass) {
- this.typeClass = Preconditions.checkNotNull(typeClass);
+ this.typeClass = requireNonNull(typeClass);
}
protected final Class<?> getTypeClass() {
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.modification;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
private final TreeNodeModification<T> rootNode;
private LazyDataTreeModification(final DataTreeIdentifier<T> path, final TreeNodeModification<T> modification) {
- this.path = Preconditions.checkNotNull(path);
- this.rootNode = Preconditions.checkNotNull(modification);
+ this.path = requireNonNull(path);
+ this.rootNode = requireNonNull(modification);
}
@Nonnull
*/
package org.opendaylight.mdsal.binding.javav2.dom.codec.modification;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
private Collection<TreeNodeModification<? extends TreeNode>> childNodesCache;
private LazyTreeNodeModification(final BindingTreeNodeCodec<T> codec, final DataTreeCandidateNode domData) {
- this.codec = Preconditions.checkNotNull(codec);
- this.domData = Preconditions.checkNotNull(domData);
+ this.codec = requireNonNull(codec);
+ this.domData = requireNonNull(domData);
this.identifier = codec.deserializePathArgument(domData.getIdentifier());
}
package org.opendaylight.mdsal.binding.javav2.generator.impl;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.processUsesImplements;
import com.google.common.annotations.Beta;
public static Module findAugmentTargetModule(final SchemaContext schemaContext,
final AugmentationSchemaNode aug) {
- Preconditions.checkNotNull(aug, "Augmentation schema can not be null.");
+ requireNonNull(aug, "Augmentation schema can not be null.");
final QName first = aug.getTargetPath().getPathFromRoot().iterator().next();
return schemaContext.findModule(first.getModule()).orElse(null);
}
*/
package org.opendaylight.mdsal.binding.javav2.generator.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
final List<Type> filteredGenTypes = new ArrayList<>();
for (final Module m : modules) {
- final ModuleContext ctx = Preconditions.checkNotNull(this.genCtx.get(m),
- "Module context not found for module %s", m);
+ final ModuleContext ctx = requireNonNull(this.genCtx.get(m),
+ () -> "Module context not found for module " + m);
filteredGenTypes.addAll(ctx.getGeneratedTypes());
final Set<Type> additionalTypes = ((TypeProviderImpl) this.typeProvider).getAdditionalTypes().get(m);
if (additionalTypes != null) {
package org.opendaylight.mdsal.binding.javav2.generator.impl;
import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.addTOToTypeBuilder;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.annotateDeprecatedIfNecessary;
import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.constructGetter;
if (superChildNode instanceof DataNodeContainer || superChildNode instanceof ChoiceSchemaNode) {
final QName childQName = createQNameFromSuperNode(module, node, superChildNode);
DataSchemaNode childNode = ((DataNodeContainer) node).getDataChildByName(childQName);
- Preconditions.checkNotNull(childNode, "%s->%s", node, childQName);
+ requireNonNull(childNode, () -> node + "->" + childQName);
final GeneratedTypeBuilder type = genCtx.get(module).getChildNode(childNode.getPath());
final GeneratedTypeBuilder superType = genCtx.get(superModule).getChildNode(superChildNode
.getPath());
- Preconditions.checkNotNull(type, "%s->%s", module, childNode.getPath());
- Preconditions.checkNotNull(superType, "%s->%s", superModule, superChildNode.getPath());
+ requireNonNull(type, () -> module + "->" + childNode.getPath());
+ requireNonNull(superType, () -> superModule + "->" + superChildNode.getPath());
type.addImplementsType(superType);
if (superChildNode instanceof ListSchemaNode
&& !((ListSchemaNode) superChildNode).getKeyDefinition().isEmpty()) {
for (CaseSchemaNode superCaseNode : ((ChoiceSchemaNode) superNode).getCases().values()) {
final QName childQName = createQNameFromSuperNode(module, node, superCaseNode);
CaseSchemaNode caseNode = ((ChoiceSchemaNode) node).getCaseNodeByName(childQName);
- Preconditions.checkNotNull(caseNode, "%s->%s", node, childQName);
+ requireNonNull(caseNode, () -> node + "->" + childQName);
final GeneratedTypeBuilder type = genCtx.get(module).getCase(caseNode.getPath());
final GeneratedTypeBuilder superType = genCtx.get(superModule).getCase(superCaseNode.getPath());
- Preconditions.checkNotNull(type, "%s->%s", module, caseNode.getPath());
- Preconditions.checkNotNull(superType, "%s->%s", superModule, superCaseNode.getPath());
+ requireNonNull(type, () -> module + "->" + caseNode.getPath());
+ requireNonNull(superType, () -> superModule + "->" + superCaseNode.getPath());
type.addImplementsType(superType);
addUsesImplements(superCaseNode, superModule, caseNode, module, schemaContext, genCtx, namespaceType);
}
}
}
- Preconditions.checkNotNull(groupingNode, "%s->%s", module, usesNode.getGroupingPath());
+ requireNonNull(groupingNode, () -> module + "->" + usesNode.getGroupingPath());
Preconditions.checkState(groupingNode instanceof GroupingDefinition, "%s->%s", module,
usesNode.getGroupingPath());
return (GroupingDefinition) groupingNode;
|| typeDef instanceof UnionTypeDefinition || typeDef instanceof BitsTypeDefinition)) {
LeafSchemaNode originalLeaf = (LeafSchemaNode) ((DerivableSchemaNode) leaf).getOriginal()
.orElse(null);
- Preconditions.checkNotNull(originalLeaf);
+ requireNonNull(originalLeaf);
returnType = genCtx.get(findParentModule(schemaContext, originalLeaf)).getInnerType(typeDef
.getPath());
} else {
final IdentitySchemaNode identity, final Module
module, final boolean verboseClassComments,
final Map<Module, ModuleContext> genCtx) {
- Preconditions.checkNotNull(identity, "Identity can not be null!");
+ requireNonNull(identity, "Identity can not be null!");
//check first if identity has been resolved as base identity of some other one
GeneratedTypeBuilder newType = findIdentityByQname(identity.getQName(), genCtx);
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
-
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes;
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final
Map<Module, ModuleContext> genCtx,
final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
- Preconditions.checkNotNull(parent, "Parent should not be NULL.");
+ requireNonNull(parent, "Parent should not be NULL.");
final Collection<DataSchemaNode> potentials = parent.getChildNodes();
for (DataSchemaNode potential : potentials) {
if (resolveDataSchemaNodesCheck(module, schemaContext, potential)) {
package org.opendaylight.mdsal.binding.javav2.generator.yang.types;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.encodeAngleBrackets;
import static org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl.addUnitsToGenTO;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
static GeneratedTransferObject wrapJavaTypeIntoTO(final String basePackageName, final TypeDefinition<?> typedef,
final Type javaType, final String moduleName, final
ModuleContext context) {
- Preconditions.checkNotNull(javaType, "javaType cannot be null");
+ requireNonNull(javaType, "javaType cannot be null");
final String propertyName = "value";
final GeneratedTOBuilderImpl genTOBuilder = typedefToTransferObject(basePackageName, typedef, moduleName,
package org.opendaylight.mdsal.binding.javav2.generator.yang.types;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.encodeAngleBrackets;
import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.packageNameWithNamespacePrefix;
import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.getOuterClassPackageName;
public List<GeneratedTOBuilder> provideGeneratedTOBuildersForUnionTypeDef(final String basePackageName,
final UnionTypeDefinition typedef, final String typeDefName, final SchemaNode parentNode,
final ModuleContext context) {
- Preconditions.checkNotNull(basePackageName, "Base Package Name cannot be NULL!");
- Preconditions.checkNotNull(typedef, "Type Definition cannot be NULL!");
- Preconditions.checkNotNull(typedef.getQName(), "Type definition QName cannot be NULL!");
+ requireNonNull(basePackageName, "Base Package Name cannot be NULL!");
+ requireNonNull(typedef, "Type Definition cannot be NULL!");
+ requireNonNull(typedef.getQName(), "Type definition QName cannot be NULL!");
final List<GeneratedTOBuilder> generatedTOBuilders = new ArrayList<>();
final List<TypeDefinition<?>> unionTypes = typedef.getTypes();
package org.opendaylight.mdsal.binding.javav2.generator.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.Objects;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
* string with the name for this <code>Type</code>
*/
protected AbstractBaseType(final String pkName, final String name, final ModuleContext context) {
- Preconditions.checkNotNull(pkName, "Package Name for Generated Type cannot be null!");
- Preconditions.checkNotNull(name, "Name of Generated Type cannot be null!");
+ requireNonNull(pkName, "Package Name for Generated Type cannot be null!");
+ requireNonNull(name, "Name of Generated Type cannot be null!");
this.packageName = JavaIdentifierNormalizer.normalizeFullPackageName(pkName);
- Preconditions.checkNotNull(context,
+ requireNonNull(context,
"In case of not having identifiers normalized, ModuleContext instance must be provided.");
this.name = JavaIdentifierNormalizer.normalizeClassIdentifier(pkName, name, context);
}
*/
protected AbstractBaseType(final String pkName, final String name, final boolean isNormalized,
final ModuleContext context) {
- Preconditions.checkNotNull(pkName, "Package Name for Generated Type cannot be null!");
- Preconditions.checkNotNull(name, "Name of Generated Type cannot be null!");
+ requireNonNull(pkName, "Package Name for Generated Type cannot be null!");
+ requireNonNull(name, "Name of Generated Type cannot be null!");
if (isNormalized) {
this.packageName = pkName;
this.name = name;
} else {
this.packageName = JavaIdentifierNormalizer.normalizeFullPackageName(pkName);
- Preconditions.checkNotNull(context,
+ requireNonNull(context,
"In case of not having identifiers normalized, ModuleContext instance must be provided.");
this.name = JavaIdentifierNormalizer.normalizeClassIdentifier(pkName, name, context);
}
protected AbstractBaseType(final String pkName, final String name, final boolean isPkNameNormalized,
final boolean isTypeNormalized, final ModuleContext context) {
- Preconditions.checkNotNull(pkName, "Package Name for Generated Type cannot be null!");
- Preconditions.checkNotNull(name, "Name of Generated Type cannot be null!");
+ requireNonNull(pkName, "Package Name for Generated Type cannot be null!");
+ requireNonNull(name, "Name of Generated Type cannot be null!");
if (isPkNameNormalized) {
this.packageName = pkName;
} else {
if (isTypeNormalized) {
this.name = name;
} else {
- Preconditions.checkNotNull(context,
+ requireNonNull(context,
"In case of not having identifiers normalized ModuleContext instance must be provided.");
this.name = JavaIdentifierNormalizer.normalizeClassIdentifier(pkName, name, context);
}
package org.opendaylight.mdsal.binding.javav2.generator.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.CharMatcher;
-import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
*/
private BaseTypeWithRestrictionsImpl(final String pkName, final String name, final Restrictions restrictions) {
super(pkName, name, null);
- this.restrictions = Preconditions.checkNotNull(restrictions);
+ this.restrictions = requireNonNull(restrictions);
}
private BaseTypeWithRestrictionsImpl(final String pkName, final String name, final Restrictions restrictions,
final ModuleContext moduleContext) {
super(pkName, name, moduleContext);
- this.restrictions = Preconditions.checkNotNull(restrictions);
+ this.restrictions = requireNonNull(restrictions);
}
@Override
private final RangeConstraint<T> rangeConstraint;
private DefaultRestrictions(final T min, final T max) {
- Preconditions.checkNotNull(min);
- Preconditions.checkNotNull(max);
+ requireNonNull(min);
+ requireNonNull(max);
this.rangeConstraint = new RangeConstraint<T>() {
@Override
package org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
@Override
public T addComment(final TypeComment typeComment) {
- this.comment = Preconditions.checkNotNull(typeComment);
+ this.comment = requireNonNull(typeComment);
return thisInstance();
}
@Override
public void setYangSourceDefinition(final YangSourceDefinition definition) {
- yangSourceDefinition = Preconditions.checkNotNull(definition);
+ yangSourceDefinition = requireNonNull(definition);
}
@Override
package org.opendaylight.mdsal.binding.javav2.java.api.generator;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
* set of types for which JAVA code should be generated
*/
public GeneratorJavaFile(final BuildContext buildContext, final Collection<? extends Type> types) {
- this.buildContext = Preconditions.checkNotNull(buildContext);
- this.types = Preconditions.checkNotNull(types);
+ this.buildContext = requireNonNull(buildContext);
+ this.types = requireNonNull(types);
this.generators.add(new EnumGenerator());
this.generators.add(new InterfaceGenerator());
this.generators.add(new BuilderGenerator());
*/
package org.opendaylight.mdsal.binding.javav2.java.api.generator.range_generators;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Range;
import java.util.ArrayList;
import java.util.Collection;
protected AbstractPrimitiveRangeGenerator(final Class<T> typeClass, final String primitiveName, final T minValue,
final T maxValue) {
super(typeClass);
- this.primitiveName = Preconditions.checkNotNull(primitiveName);
- this.minValue = Preconditions.checkNotNull(minValue);
- this.maxValue = Preconditions.checkNotNull(maxValue);
+ this.primitiveName = requireNonNull(primitiveName);
+ this.minValue = requireNonNull(minValue);
+ this.maxValue = requireNonNull(maxValue);
}
/**
*/
package org.opendaylight.mdsal.binding.javav2.java.api.generator.range_generators;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import java.util.Map;
private final Class<T> type;
protected AbstractRangeGenerator(final Class<T> typeClass) {
- this.type = Preconditions.checkNotNull(typeClass);
+ this.type = requireNonNull(typeClass);
}
public static AbstractRangeGenerator<?> forType(@Nonnull final Type type) {
package org.opendaylight.mdsal.binding.javav2.java.api.generator.renderers;
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.ImmutableMap;
import java.util.Collection;
private final Map<String, String> importedNames = new HashMap<>();
protected BaseRenderer(final GeneratedType type) {
- this.genType = Preconditions.checkNotNull(type);
+ this.genType = requireNonNull(type);
this.importMap = new HashMap<>();
}
checkArgument(parentGenType.getPackageName() != null,
"Parent Generated Type cannot have Package Name referenced as NULL!");
- final String typeName = Preconditions.checkNotNull(type.getName());
- final String typePackageName = Preconditions.checkNotNull(type.getPackageName());
- final String parentTypeName = Preconditions.checkNotNull(parentGenType.getName());
+ final String typeName = requireNonNull(type.getName());
+ final String typePackageName = requireNonNull(type.getPackageName());
+ final String parentTypeName = requireNonNull(parentGenType.getName());
if (typeName.equals(parentTypeName) || typePackageName.startsWith("java.lang") || typePackageName.isEmpty()) {
return;
}
checkArgument(type != null, "Type parameter MUST be specified and cannot be NULL!");
checkArgument(importMap != null, "Imports Map cannot be NULL!");
- final String typePackageName = Preconditions.checkNotNull(type.getPackageName());
- final String typeName = Preconditions.checkNotNull(type.getName());
+ final String typePackageName = requireNonNull(type.getPackageName());
+ final String typeName = requireNonNull(type.getName());
final String importedPackageName = importMap.get(typeName);
final StringBuilder sb;
if (typePackageName.equals(importedPackageName)) {
protected String getterMethod(final GeneratedProperty field) {
final StringBuilder sb = new StringBuilder();
final String name = TextTemplateUtil.fieldName(field);
- final String importedName = Preconditions.checkNotNull(importedName(field.getReturnType()));
+ final String importedName = requireNonNull(importedName(field.getReturnType()));
sb.append("public ")
.append(importedName)
.append(' ')
package org.opendaylight.mdsal.binding.javav2.java.api.generator.renderers;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.javav2.java.api.generator.util.TextTemplateUtil.fieldName;
import static org.opendaylight.mdsal.binding.javav2.java.api.generator.util.TextTemplateUtil.setterMethod;
if (restrictions != null && restrictions.getRangeConstraint().isPresent()) {
rangeGenerator = AbstractRangeGenerator.forType(findProperty(genType, "value").getReturnType());
- Preconditions.checkNotNull(rangeGenerator);
+ requireNonNull(rangeGenerator);
} else {
rangeGenerator = null;
}
package org.opendaylight.mdsal.binding.javav2.java.api.generator.renderers;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayDeque;
import java.util.ArrayList;
*/
public InterfaceRenderer(final GeneratedType type) {
super(type);
- Preconditions.checkNotNull(type, "Generated type reference cannot be NULL!");
+ requireNonNull(type, "Generated type reference cannot be NULL!");
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.java.api.generator.renderers;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.BOOLEAN;
import com.google.common.base.Preconditions;
final StringBuilder sb1 = new StringBuilder();
final String name = TextTemplateUtil.fieldName(field);
- final String importedName = Preconditions.checkNotNull(importedName(field.getReturnType()));
+ final String importedName = requireNonNull(importedName(field.getReturnType()));
sb1.append("public ")
.append(importedName)
.append(' ')
package org.opendaylight.mdsal.binding.javav2.java.api.generator.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.CharMatcher;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
* @return underscored string form
*/
public static String fieldName(final GeneratedProperty property) {
- final String name = Preconditions.checkNotNull(property.getName());
+ final String name = requireNonNull(property.getName());
return UNDERSCORE.concat(name);
}
* @return getter for property
*/
public static String getterMethodName(final GeneratedProperty field) {
- final Type type = Preconditions.checkNotNull(field.getReturnType());
- final String name = Preconditions.checkNotNull(field.getName());
+ final Type type = requireNonNull(field.getReturnType());
+ final String name = requireNonNull(field.getName());
final String prefix = Types.BOOLEAN.equals(type) ? "is" : "get";
return prefix.concat(toFirstUpper(name));
}
* @return getter name without prefix
*/
public static String propertyNameFromGetter(final MethodSignature getter) {
- final String name = Preconditions.checkNotNull(getter.getName());
+ final String name = requireNonNull(getter.getName());
int prefix;
if (name.startsWith("is")) {
prefix = 2;
package org.opendaylight.mdsal.binding.javav2.maven.api.gen.plugin;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer.normalizeFullPackageName;
import static org.opendaylight.mdsal.binding.javav2.util.BindingMapping.getRootPackageName;
import com.google.common.annotations.Beta;
import com.google.common.base.Joiner;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
import java.io.BufferedWriter;
@Override
public void setBuildContext(BuildContext buildContext) {
- this.buildContext = Preconditions.checkNotNull(buildContext);
+ this.buildContext = requireNonNull(buildContext);
}
@Override
*/
package org.opendaylight.mdsal.binding.javav2.runtime.context;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
private Entry<GeneratedType, Object> getTypeWithSchema(final Type referencedType) {
final Object schema = this.typeToDefiningSchema.get(referencedType);
- Preconditions.checkNotNull(schema, "Failed to find schema for type %s", referencedType);
+ requireNonNull(schema, () -> "Failed to find schema for type " + referencedType);
final Type definedType = this.typeToDefiningSchema.inverse().get(schema);
- Preconditions.checkNotNull(definedType, "Failed to find defined type for %s schema %s", referencedType, schema);
+ requireNonNull(definedType, () -> "Failed to find defined type for " + referencedType + " schema " + schema);
if (definedType instanceof GeneratedTypeBuilder) {
return new SimpleEntry<>(((GeneratedTypeBuilder) definedType).toInstance(), schema);
*/
package org.opendaylight.mdsal.binding.javav2.runtime.javassist;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import java.util.Collection;
private final ClassPool classPool;
private JavassistUtils(final ClassPool pool) {
- classPool = Preconditions.checkNotNull(pool);
+ classPool = requireNonNull(pool);
}
/**
* @return shared utility instance for specified pool
*/
public static synchronized JavassistUtils forClassPool(final ClassPool pool) {
- JavassistUtils ret = INSTANCES.get(Preconditions.checkNotNull(pool));
+ JavassistUtils ret = INSTANCES.get(requireNonNull(pool));
if (ret == null) {
ret = new JavassistUtils(pool);
INSTANCES.put(pool, ret);
package org.opendaylight.mdsal.binding.javav2.runtime.reflection;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
private final MethodHandle fieldGetter;
ReflectionAugmentationFieldGetter(final MethodHandle mh) {
- this.fieldGetter = Preconditions.checkNotNull(mh);
+ this.fieldGetter = requireNonNull(mh);
}
@Override
package org.opendaylight.mdsal.binding.javav2.spec.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
/**
* An IdentifiableItem represents a object that is usually present in a collection and can be
private final T key;
public IdentifiableItem(final Class<I> type, final T key) {
- this.type = Preconditions.checkNotNull(type);
- this.key = Preconditions.checkNotNull(key, "Key may not be null.");
+ this.type = requireNonNull(type);
+ this.key = requireNonNull(key, "Key may not be null.");
}
@Override
package org.opendaylight.mdsal.binding.javav2.spec.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
}
InstanceIdentifier(final Class<T> type, final Iterable<TreeArgument> pathArguments, final boolean wildcarded, final int hash) {
- this.pathArguments = Preconditions.checkNotNull(pathArguments);
- this.targetType = Preconditions.checkNotNull(type);
+ this.pathArguments = requireNonNull(pathArguments);
+ this.targetType = requireNonNull(type);
this.wildcarded = wildcarded;
this.hash = hash;
}
*/
@Override
public final boolean contains(final InstanceIdentifier<? extends TreeNode> other) {
- Preconditions.checkNotNull(other, "other should not be null");
+ requireNonNull(other, "other should not be null");
final Iterator<?> lit = pathArguments.iterator();
final Iterator<?> oit = other.pathArguments.iterator();
* @return true if this identifier contains the other object
*/
public final boolean containsWildcarded(final InstanceIdentifier<?> other) {
- Preconditions.checkNotNull(other, "other should not be null");
+ requireNonNull(other, "other should not be null");
final Iterator<TreeArgument> lit = pathArguments.iterator();
final Iterator<TreeArgument> oit = other.pathArguments.iterator();
* contains a null element.
*/
private static InstanceIdentifier<?> internalCreate(final Iterable<TreeArgument> pathArguments) {
- final Iterator<? extends TreeArgument> it = Preconditions.checkNotNull(pathArguments, "pathArguments may not be null").iterator();
+ final Iterator<? extends TreeArgument> it = requireNonNull(pathArguments, "pathArguments may not be null").iterator();
final HashCodeBuilder<TreeArgument> hashBuilder = new HashCodeBuilder<>();
boolean wildcard = false;
TreeArgument a = null;
public static <N extends TreeNode, K> K keyOf(
final InstanceIdentifier<N> id) {
- Preconditions.checkNotNull(id);
+ requireNonNull(id);
Preconditions.checkArgument(id instanceof KeyedInstanceIdentifier, "%s does not have a key", id);
@SuppressWarnings("unchecked")
package org.opendaylight.mdsal.binding.javav2.spec.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
/**
* An Item represents an object that probably is only one of it's kind. For example a Nodes object
private final Class<T> type;
public Item(final Class<T> type) {
- this.type = Preconditions.checkNotNull(type);
+ this.type = requireNonNull(type);
}
@Override
package org.opendaylight.mdsal.binding.javav2.spec.runtime;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
/**
* Binding Namespace is structure of Java packages designed to prevent conflicts in YANG Java
private final String packagePrefix;
BindingNamespaceType(String packagePrefix) {
- this.packagePrefix = Preconditions.checkNotNull(packagePrefix);
+ this.packagePrefix = requireNonNull(packagePrefix);
}
public String getPackagePrefix() {
package org.opendaylight.mdsal.binding.javav2.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
private final T template;
private StringValueObjectFactory(final T template, final MethodHandle constructor, final MethodHandle setter) {
- this.template = Preconditions.checkNotNull(template);
+ this.template = requireNonNull(template);
this.constructor = constructor.bindTo(template);
- this.setter = Preconditions.checkNotNull(setter);
+ this.setter = requireNonNull(setter);
}
public static <T> StringValueObjectFactory<T> create(final Class<T> clazz, final String templateString) {
}
public T newInstance(final String string) {
- Preconditions.checkNotNull(string, "Argument may not be null");
+ requireNonNull(string, "Argument may not be null");
try {
final T ret = (T) constructor.invokeExact();
*/
package org.opendaylight.mdsal.dom.broker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
AbstractDOMRoutingTable(final Map<SchemaPath, E> operations,
final SchemaContext schemaContext) {
- this.operations = Preconditions.checkNotNull(operations);
+ this.operations = requireNonNull(operations);
this.schemaContext = schemaContext;
}
*/
package org.opendaylight.mdsal.dom.broker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import java.util.ArrayList;
private final SchemaPath type;
AbstractDOMRoutingTableEntry(final SchemaPath type, final Map<D, List<M>> implementations) {
- this.type = Preconditions.checkNotNull(type);
- this.implementations = Preconditions.checkNotNull(implementations);
+ this.type = requireNonNull(type);
+ this.implementations = requireNonNull(implementations);
}
SchemaPath getType() {
*/
package org.opendaylight.mdsal.dom.broker;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Maps;
import java.util.Comparator;
import java.util.List;
AbstractDOMRpcRoutingTableEntry(final DOMRpcIdentifier rpcId, final Map<YangInstanceIdentifier,
List<DOMRpcImplementation>> implementations) {
super(rpcId.getType(), implementations);
- this.rpcId = Preconditions.checkNotNull(rpcId);
+ this.rpcId = requireNonNull(rpcId);
}
final DOMRpcIdentifier getRpcId() {
*/
package org.opendaylight.mdsal.dom.broker;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Throwables;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
CommitCoordinationTask(final DOMDataTreeWriteTransaction transaction,
final Collection<DOMStoreThreePhaseCommitCohort> cohorts,
final DurationStatisticsTracker commitStatTracker) {
- this.tx = Preconditions.checkNotNull(transaction, "transaction must not be null");
- this.cohorts = Preconditions.checkNotNull(cohorts, "cohorts must not be null");
+ this.tx = requireNonNull(transaction, "transaction must not be null");
+ this.cohorts = requireNonNull(cohorts, "cohorts must not be null");
this.commitStatTracker = commitStatTracker;
}
package org.opendaylight.mdsal.dom.broker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
final AbstractDOMDataBroker broker, final DOMTransactionChainListener listener) {
super(chains);
this.chainId = chainId;
- this.broker = Preconditions.checkNotNull(broker);
- this.listener = Preconditions.checkNotNull(listener);
+ this.broker = requireNonNull(broker);
+ this.listener = requireNonNull(listener);
}
private void checkNotFailed() {
*/
package org.opendaylight.mdsal.dom.broker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeShard;
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
public DOMDataTreeShardRegistration(final ShardedDOMDataTree tree, final DOMDataTreeIdentifier prefix,
final T shard) {
super(shard);
- this.tree = Preconditions.checkNotNull(tree);
- this.prefix = Preconditions.checkNotNull(prefix);
+ this.tree = requireNonNull(tree);
+ this.prefix = requireNonNull(prefix);
}
public DOMDataTreeIdentifier getPrefix() {
*/
package org.opendaylight.mdsal.dom.broker;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import com.lmax.disruptor.EventFactory;
@SuppressWarnings("checkstyle:hiddenField")
ListenableFuture<Void> initialize(final DOMNotification notification,
final Collection<ListenerRegistration<? extends DOMNotificationListener>> subscribers) {
- this.notification = Preconditions.checkNotNull(notification);
- this.subscribers = Preconditions.checkNotNull(subscribers);
+ this.notification = requireNonNull(notification);
+ this.subscribers = requireNonNull(subscribers);
this.future = SettableFuture.create();
return this.future;
}
*/
package org.opendaylight.mdsal.dom.broker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
public SerializedDOMDataBroker(final Map<LogicalDatastoreType, DOMStore> datastores,
final ListeningExecutorService executor) {
super(datastores);
- this.executor = Preconditions.checkNotNull(executor, "executor must not be null.");
+ this.executor = requireNonNull(executor, "executor must not be null.");
}
public DurationStatisticsTracker getCommitStatsTracker() {
*/
package org.opendaylight.mdsal.dom.broker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import com.google.common.collect.ImmutableSet;
ShardedDOMDataTreeProducer(final ShardedDOMDataTree dataTree,
final Collection<DOMDataTreeIdentifier> subtrees,
final Map<DOMDataTreeIdentifier, DOMDataTreeShard> shardMap) {
- this.dataTree = Preconditions.checkNotNull(dataTree);
+ this.dataTree = requireNonNull(dataTree);
this.subtrees = ImmutableSet.copyOf(subtrees);
this.layout = ProducerLayout.create(shardMap);
}
void bindToListener(final DOMDataTreeListener listener) {
final DOMDataTreeListener local = attachedListener;
Preconditions.checkState(local == null, "Producer %s is already attached to listener %s", this, local);
- this.attachedListener = Preconditions.checkNotNull(listener);
+ this.attachedListener = requireNonNull(listener);
}
}
*/
package org.opendaylight.mdsal.dom.broker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.FluentFuture;
ShardedDOMDataTreeWriteTransaction(final ShardedDOMDataTreeProducer producer,
final Map<DOMDataTreeIdentifier, DOMDataTreeShardWriteTransaction> transactions, final ProducerLayout layout) {
- this.producer = Preconditions.checkNotNull(producer);
+ this.producer = requireNonNull(producer);
this.transactions = ImmutableMap.copyOf(transactions);
- this.layout = Preconditions.checkNotNull(layout);
+ this.layout = requireNonNull(layout);
this.identifier = "SHARDED-DOM-" + COUNTER.getAndIncrement();
LOG.debug("Created new transaction {}", identifier);
}
private final DOMDataTreeIdentifier rootPosition;
DelegatingCursor(final DOMDataTreeWriteCursor delegate, final DOMDataTreeIdentifier rootPosition) {
- this.delegate = Preconditions.checkNotNull(delegate);
- this.rootPosition = Preconditions.checkNotNull(rootPosition);
+ this.delegate = requireNonNull(delegate);
+ this.rootPosition = requireNonNull(rootPosition);
currentArgs.addAll(rootPosition.getRootIdentifier().getPathArguments());
}
*/
package org.opendaylight.mdsal.dom.broker;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
public TransactionChainWriteTransaction(final Object identifier, final DOMDataTreeWriteTransaction delegateTx,
final ShardedDOMTransactionChainAdapter txChain) {
- this.delegateTx = Preconditions.checkNotNull(delegateTx);
- this.identifier = Preconditions.checkNotNull(identifier);
- this.txChain = Preconditions.checkNotNull(txChain);
+ this.delegateTx = requireNonNull(delegateTx);
+ this.identifier = requireNonNull(identifier);
+ this.txChain = requireNonNull(txChain);
}
*/
package org.opendaylight.mdsal.dom.store.inmemory;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
final DOMStoreTransactionChainImpl txChain,
final Exception operationError) {
super(store, transaction, modification, operationError);
- this.txChain = Preconditions.checkNotNull(txChain);
+ this.txChain = requireNonNull(txChain);
}
@Override
*/
package org.opendaylight.mdsal.dom.store.inmemory;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.mdsal.dom.spi.store.AbstractSnapshotBackedTransactionChain;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
private final InMemoryDOMDataStore store;
DOMStoreTransactionChainImpl(final InMemoryDOMDataStore store) {
- this.store = Preconditions.checkNotNull(store);
+ this.store = requireNonNull(store);
}
@Override
*/
package org.opendaylight.mdsal.dom.store.inmemory;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ForwardingObject;
import java.util.Optional;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
private final DataTreeModificationCursor delegate;
private DataTreeModificationCursorAdaptor(final DataTreeModificationCursor delegate) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
}
static DataTreeModificationCursorAdaptor of(final DataTreeModificationCursor dataTreeCursor) {
package org.opendaylight.mdsal.dom.store.inmemory;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
public ForeignShardThreePhaseCommitCohort(final DOMDataTreeIdentifier prefix,
final ForeignShardModificationContext shard) {
- this.prefix = Preconditions.checkNotNull(prefix);
- this.shard = Preconditions.checkNotNull(shard);
+ this.prefix = requireNonNull(prefix);
+ this.shard = requireNonNull(shard);
}
@Override
package org.opendaylight.mdsal.dom.store.inmemory;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
InMemoryDOMDataTreeShardThreePhaseCommitCohort(final DataTree dataTree,
final DataTreeModification modification,
final InMemoryDOMDataTreeShardChangePublisher changePublisher) {
- this.dataTree = Preconditions.checkNotNull(dataTree);
- this.modification = Preconditions.checkNotNull(modification);
- this.changePublisher = Preconditions.checkNotNull(changePublisher);
+ this.dataTree = requireNonNull(dataTree);
+ this.modification = requireNonNull(modification);
+ this.changePublisher = requireNonNull(changePublisher);
}
@SuppressWarnings("checkstyle:IllegalCatch")
package org.opendaylight.mdsal.dom.store.inmemory;
import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
final SnapshotBackedWriteTransaction<String> writeTransaction,
final DataTreeModification modification,
final Exception operationError) {
- this.transaction = Preconditions.checkNotNull(writeTransaction);
- this.modification = Preconditions.checkNotNull(modification);
- this.store = Preconditions.checkNotNull(store);
+ this.transaction = requireNonNull(writeTransaction);
+ this.modification = requireNonNull(modification);
+ this.store = requireNonNull(store);
this.operationError = operationError;
}
package org.opendaylight.mdsal.dom.store.inmemory;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.mdsal.dom.spi.shard.AbstractDataModificationCursor;
import org.opendaylight.mdsal.dom.spi.shard.WriteCursorStrategy;
InMemoryShardDataModificationCursor(final ShardDataModification root,
final InmemoryDOMDataTreeShardWriteTransaction parent) {
super(root);
- this.parent = Preconditions.checkNotNull(parent);
+ this.parent = requireNonNull(parent);
}
@Override
*/
package org.opendaylight.mdsal.dom.store.inmemory;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
final DOMDataTreeIdentifier root,
final Map<PathArgument, WriteableModificationNode> children,
final Map<DOMDataTreeIdentifier, ForeignShardModificationContext> childShards) {
- this.root = Preconditions.checkNotNull(root);
+ this.root = requireNonNull(root);
this.children = ImmutableMap.copyOf(children);
this.childShards = ImmutableMap.copyOf(childShards);
}
package org.opendaylight.mdsal.dom.store.inmemory;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
final InMemoryDOMDataTreeShardChangePublisher changePublisher,
final ListeningExecutorService executor) {
this.producer = producer;
- this.modification = Preconditions.checkNotNull(root);
- this.rootShardDataTree = Preconditions.checkNotNull(rootShardDataTree);
- this.changePublisher = Preconditions.checkNotNull(changePublisher);
+ this.modification = requireNonNull(root);
+ this.rootShardDataTree = requireNonNull(rootShardDataTree);
+ this.changePublisher = requireNonNull(changePublisher);
this.identifier = "INMEMORY-SHARD-TX-" + COUNTER.getAndIncrement();
LOG.debug("Shard transaction{} created", identifier);
this.executor = executor;
}
void cursorClosed() {
- Preconditions.checkNotNull(cursor);
+ requireNonNull(cursor);
modification.closeCursor();
cursor = null;
}
public void ready() {
Preconditions.checkState(!finished, "Attempting to ready an already finished transaction.");
Preconditions.checkState(cursor == null, "Attempting to ready a transaction that has an open cursor.");
- Preconditions.checkNotNull(modification, "Attempting to ready an empty transaction.");
+ requireNonNull(modification, "Attempting to ready an empty transaction.");
LOG.debug("Readying open transaction on shard {}", modification.getPrefix());
rootModification = modification.seal();
public ListenableFuture<Void> submit() {
LOG.debug("Submitting open transaction on shard {}", modification.getPrefix());
- Preconditions.checkNotNull(cohorts);
+ requireNonNull(cohorts);
Preconditions.checkState(!cohorts.isEmpty(), "Transaction was not readied yet.");
return executor.submit(new ShardSubmitCoordinationTask(modification.getPrefix(), cohorts, this));
}
DataTreeModification getRootModification() {
- Preconditions.checkNotNull(rootModification, "Transaction wasn't sealed yet");
+ requireNonNull(rootModification, "Transaction wasn't sealed yet");
return rootModification;
}
package org.opendaylight.mdsal.dom.store.inmemory;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.concurrent.Callable;
public ShardCanCommitCoordinationTask(final DOMDataTreeIdentifier rootShardPrefix,
final Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
- this.rootShardPrefix = Preconditions.checkNotNull(rootShardPrefix);
- this.cohorts = Preconditions.checkNotNull(cohorts);
+ this.rootShardPrefix = requireNonNull(rootShardPrefix);
+ this.cohorts = requireNonNull(cohorts);
}
@Override
package org.opendaylight.mdsal.dom.store.inmemory;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.concurrent.Callable;
public ShardCommitCoordinationTask(final DOMDataTreeIdentifier rootShardPrefix,
final Collection<DOMStoreThreePhaseCommitCohort> cohorts,
final InmemoryDOMDataTreeShardWriteTransaction transaction) {
- this.rootShardPrefix = Preconditions.checkNotNull(rootShardPrefix);
- this.cohorts = Preconditions.checkNotNull(cohorts);
- this.transaction = Preconditions.checkNotNull(transaction);
+ this.rootShardPrefix = requireNonNull(rootShardPrefix);
+ this.cohorts = requireNonNull(cohorts);
+ this.transaction = requireNonNull(transaction);
}
@Override
package org.opendaylight.mdsal.dom.store.inmemory;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
final Map<PathArgument, WriteableModificationNode> subshards,
final Map<DOMDataTreeIdentifier, ForeignShardModificationContext> childShards) {
super(subshards);
- this.rootContext = Preconditions.checkNotNull(boundary);
+ this.rootContext = requireNonNull(boundary);
this.childShards = ImmutableMap.copyOf(childShards);
}
package org.opendaylight.mdsal.dom.store.inmemory;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
protected final Map<DOMDataTreeIdentifier, ForeignShardModificationContext> childShards = new HashMap<>();
public ShardDataModificationFactoryBuilder(final DOMDataTreeIdentifier root) {
- this.root = Preconditions.checkNotNull(root);
+ this.root = requireNonNull(root);
}
public void addSubshard(final ForeignShardModificationContext value) {
package org.opendaylight.mdsal.dom.store.inmemory;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
ShardRootModificationContext(final DOMDataTreeIdentifier identifier,
final CursorAwareDataTreeSnapshot snapshot) {
- this.identifier = Preconditions.checkNotNull(identifier);
- this.snapshot = Preconditions.checkNotNull(snapshot);
+ this.identifier = requireNonNull(identifier);
+ this.snapshot = requireNonNull(snapshot);
}
@Override
package org.opendaylight.mdsal.dom.store.inmemory;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.concurrent.Callable;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
public ShardSubmitCoordinationTask(final DOMDataTreeIdentifier rootShardPrefix,
final Collection<DOMStoreThreePhaseCommitCohort> cohorts,
final InmemoryDOMDataTreeShardWriteTransaction transaction) {
- this.rootShardPrefix = Preconditions.checkNotNull(rootShardPrefix);
+ this.rootShardPrefix = requireNonNull(rootShardPrefix);
this.transaction = transaction;
canCommitCoordinationTask = new ShardCanCommitCoordinationTask(rootShardPrefix, cohorts);
*/
package org.opendaylight.mdsal.eos.binding.dom.adapter;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipCandidateRegistration;
BindingEntityOwnershipCandidateRegistration(DOMEntityOwnershipCandidateRegistration domRegistration,
Entity entity) {
super(entity);
- this.domRegistration = Preconditions.checkNotNull(domRegistration);
+ this.domRegistration = requireNonNull(domRegistration);
}
@Override
*/
package org.opendaylight.mdsal.eos.binding.dom.adapter;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
BindingEntityOwnershipListenerRegistration(String entityType, EntityOwnershipListener listener,
DOMEntityOwnershipListenerRegistration domRegistration) {
super(listener);
- this.entityType = Preconditions.checkNotNull(entityType);
- this.domRegistration = Preconditions.checkNotNull(domRegistration);
+ this.entityType = requireNonNull(entityType);
+ this.domRegistration = requireNonNull(domRegistration);
}
@Override
*/
package org.opendaylight.mdsal.eos.binding.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
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;
public Entity(final @NonNull String type, final @NonNull String entityName) {
super(type, InstanceIdentifier.builder(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
.mdsal.core.general.entity.rev150930.Entity.class,
- new EntityKey(Preconditions.checkNotNull(entityName, "entityName should not be null"))).build());
+ new EntityKey(requireNonNull(entityName, "entityName should not be null"))).build());
}
}
*/
package org.opendaylight.mdsal.eos.dom.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.eos.common.api.GenericEntity;
import org.opendaylight.yangtools.yang.common.QName;
*/
public DOMEntity(final @NonNull String type, final @NonNull String entityName) {
super(type, YangInstanceIdentifier.builder().node(ENTITY).nodeWithKey(ENTITY, ENTITY_NAME,
- Preconditions.checkNotNull(entityName, "entityName should not be null")).build());
+ requireNonNull(entityName, "entityName should not be null")).build());
}
}
*/
package org.opendaylight.mdsal.eos.dom.simple;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState.LOCAL_OWNERSHIP_GRANTED;
import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState.LOCAL_OWNERSHIP_LOST_NO_OWNER;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.ImmutableList;
@VisibleForTesting
SimpleDOMEntityOwnershipService(final UUID uuid) {
- this.uuid = Preconditions.checkNotNull(uuid);
+ this.uuid = requireNonNull(uuid);
}
public SimpleDOMEntityOwnershipService() {
ListenerRegistration(final String entityType, final DOMEntityOwnershipListener listener) {
super(listener);
- this.entityType = Preconditions.checkNotNull(entityType);
+ this.entityType = requireNonNull(entityType);
}
@Override
package org.opendaylight.mdsal.model.ietf.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
public class IpClass {
private final String _value;
public IpClass(final String value) {
- this._value = Preconditions.checkNotNull(value);
+ this._value = requireNonNull(value);
}
public IpClass(final IpClass template) {
Code Review / mdsal.git / commitdiff