}
@Override
- public void visitToken(DetailAST ast) {
+ public void visitToken(final DetailAST ast) {
String methodName = CheckLoggingUtil.getMethodName(ast);
if (CheckLoggingUtil.isLogMethod(methodName)) {
Optional<String> optLogMessage = getLogMessage(ast);
}
}
- private Optional<String> getLogMessage(DetailAST ast) {
+ private static Optional<String> getLogMessage(DetailAST ast) {
ast = ast.findFirstToken(TokenTypes.ELIST);
if (ast != null) {
ast = ast.getFirstChild();
package org.opendaylight.yangtools.checkstyle;
-import com.google.common.collect.Lists;
+import com.google.common.collect.ImmutableSet;
import com.puppycrawl.tools.checkstyle.api.DetailAST;
import com.puppycrawl.tools.checkstyle.api.FullIdent;
import com.puppycrawl.tools.checkstyle.api.TokenTypes;
import com.puppycrawl.tools.checkstyle.utils.CheckUtils;
-import java.util.List;
+import java.util.Set;
import org.slf4j.Logger;
public final class CheckLoggingUtil {
public static final String LOGGER_TYPE_NAME = Logger.class.getSimpleName();
public static final String LOGGER_TYPE_FULL_NAME = Logger.class.getName();
public static final String LOGGER_VAR_NAME = "LOG";
- private static final List<String> LOG_METHODS =
- Lists.newArrayList("LOG.debug", "LOG.info", "LOG.error", "LOG.warn", "LOG.trace");
+
+ private static final Set<String> LOG_METHODS = ImmutableSet.of(
+ "LOG.debug", "LOG.info", "LOG.error", "LOG.warn", "LOG.trace");
private CheckLoggingUtil() {
throw new UnsupportedOperationException("Utility class should not be instantiated!");
}
@Override
- public void visitToken(DetailAST ast) {
+ public void visitToken(final DetailAST ast) {
final String methodName = CheckLoggingUtil.getMethodName(ast);
if (CheckLoggingUtil.isLogMethod(methodName)) {
DetailAST plus = ast.findFirstToken(TokenTypes.ELIST).getFirstChild().findFirstToken(TokenTypes.PLUS);
*/
package org.opendaylight.yangtools.checkstyle;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.io.FileWriteMode;
import com.google.common.io.Files;
import com.puppycrawl.tools.checkstyle.api.DetailAST;
import java.io.File;
private File logMessagesReportFile = DEFAULT_REPORT_FILE;
- public void setLogMessagesReportFileName(String fileName) {
+ public void setLogMessagesReportFileName(final String fileName) {
logMessagesReportFile = new File(fileName);
logMessagesReportFile.getParentFile().mkdirs();
}
}
@Override
- protected void visitLogMessage(DetailAST ast, String logMessage) {
+ protected void visitLogMessage(final DetailAST ast, final String logMessage) {
File file = new File(getFileContents().getFileName());
String fileName = FileNameUtil.getPathRelativeToMavenProjectRootIfPossible(file).getPath();
int lineNumber = ast.getLineNo();
updateMessagesReportFile(log);
}
- protected void updateMessagesReportFile(LogMessageOccurence log) {
+ protected void updateMessagesReportFile(final LogMessageOccurence log) {
try {
final File file = getLogMessagesReportFile();
file.getParentFile().mkdirs();
- if (file.exists()) {
- Files.append(log.toString() + "\n", file, StandardCharsets.UTF_8);
- } else {
- Files.write(log.toString() + "\n", file, StandardCharsets.UTF_8);
- }
+ Files.asCharSink(file, StandardCharsets.UTF_8, FileWriteMode.APPEND).write(log.toString() + "\n");
} catch (IOException e) {
LOG.error("Failed to append to file: {}", logMessagesReportFile.getPath(), e);
}
public final int lineNumber;
public final String message;
- public LogMessageOccurence(String javaSourceFilePath, int lineNumber, String message) {
- this.javaSourceFilePath = Preconditions.checkNotNull(javaSourceFilePath, "javaSourceFilePath");
+ public LogMessageOccurence(final String javaSourceFilePath, final int lineNumber, final String message) {
+ this.javaSourceFilePath = requireNonNull(javaSourceFilePath, "javaSourceFilePath");
this.lineNumber = lineNumber;
- this.message = Preconditions.checkNotNull(message, "message");
+ this.message = requireNonNull(message, "message");
}
@Override
private static final String EXCEPTION_TYPE = "Exception";
@Override
- protected void visitLogMessage(DetailAST ast, String logMessage) {
+ protected void visitLogMessage(final DetailAST ast, final String logMessage) {
int placeholdersCount = placeholdersCount(logMessage);
int argumentsCount = ast.findFirstToken(TokenTypes.ELIST).getChildCount(TokenTypes.EXPR) - 1;
final String lastArg = ast.findFirstToken(TokenTypes.ELIST).getLastChild().getFirstChild().getText();
}
}
- private int placeholdersCount(final String message) {
+ private static int placeholdersCount(final String message) {
return (message.length() - message.replace(PLACEHOLDER, "").length()) / PLACEHOLDER.length();
}
- private boolean hasCatchBlockParentWithArgument(final String argumentName, final DetailAST ast) {
+ private static boolean hasCatchBlockParentWithArgument(final String argumentName, final DetailAST ast) {
DetailAST parent = ast.getParent();
while (parent != null && parent.getType() != TokenTypes.LITERAL_CATCH) {
parent = parent.getParent();
return false;
}
- private boolean hasMethodDefinitionWithExceptionArgument(final String argumentName, final DetailAST ast) {
+ private static boolean hasMethodDefinitionWithExceptionArgument(final String argumentName, final DetailAST ast) {
DetailAST parent = ast.getParent();
while (parent != null && parent.getType() != TokenTypes.METHOD_DEF) {
parent = parent.getParent();
return false;
}
- private boolean isExceptionType(final DetailAST parameterDef) {
+ private static boolean isExceptionType(final DetailAST parameterDef) {
if (parameterDef != null) {
final DetailAST type = parameterDef.findFirstToken(TokenTypes.TYPE);
if (type != null && type.findFirstToken(TokenTypes.IDENT) != null) {
package org.opendaylight.yangtools.checkstyle;
-import com.google.common.base.Optional;
import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
import com.puppycrawl.tools.checkstyle.api.DetailAST;
import com.puppycrawl.tools.checkstyle.api.TokenTypes;
+import java.util.Optional;
public class LoggerFactoryClassParameterCheck extends AbstractCheck {
}
@Override
- public void visitToken(DetailAST ast) {
+ public void visitToken(final DetailAST ast) {
final String methodName = CheckLoggingUtil.getMethodName(ast);
if (methodName.equals(METHOD_NAME)) {
final String className = CheckLoggingUtil.getClassName(ast);
}
}
- protected Optional<String> getFirstArgument(DetailAST ast) {
+ protected Optional<String> getFirstArgument(final DetailAST ast) {
final DetailAST findFirstToken = ast.findFirstToken(TokenTypes.ELIST);
if (findFirstToken != null) {
DetailAST childToken = findFirstToken.getFirstChild();
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
}
}
@Override
- public void visitToken(DetailAST ast) {
+ public void visitToken(final DetailAST ast) {
if (CheckLoggingUtil.isAFieldVariable(ast) && CheckLoggingUtil.isLoggerType(ast)
&& !hasPrivatStaticFinalModifier(ast)) {
log(ast.getLineNo(), LOG_MESSAGE);
}
}
- private boolean hasPrivatStaticFinalModifier(DetailAST ast) {
- DetailAST modifiers = ast.findFirstToken(TokenTypes.MODIFIERS);
- if (modifiers != null && modifiers.branchContains(TokenTypes.LITERAL_PRIVATE)
- && modifiers.branchContains(TokenTypes.LITERAL_STATIC) && modifiers.branchContains(TokenTypes.FINAL)) {
- return true;
- }
- return false;
+ private static boolean hasPrivatStaticFinalModifier(final DetailAST ast) {
+ final DetailAST modifiers = ast.findFirstToken(TokenTypes.MODIFIERS);
+ return modifiers != null && modifiers.branchContains(TokenTypes.LITERAL_PRIVATE)
+ && modifiers.branchContains(TokenTypes.LITERAL_STATIC) && modifiers.branchContains(TokenTypes.FINAL);
}
-
}
}
@Override
- public void visitToken(DetailAST ast) {
+ public void visitToken(final DetailAST ast) {
if (CheckLoggingUtil.isAFieldVariable(ast) && CheckLoggingUtil.isLoggerType(ast)
&& !LOGGER_VAR_NAME.equals(CheckLoggingUtil.getVariableName(ast))) {
log(ast.getLineNo(), LOG_MESSAGE);
}
}
-
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
-import com.google.common.io.Files;
import com.puppycrawl.tools.checkstyle.Checker;
import com.puppycrawl.tools.checkstyle.ConfigurationLoader;
import com.puppycrawl.tools.checkstyle.DefaultLogger;
import com.puppycrawl.tools.checkstyle.api.Configuration;
import java.io.ByteArrayOutputStream;
import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
import java.util.List;
import org.junit.After;
import org.junit.Before;
File logMessageReport = LogMessageExtractorCheck.DEFAULT_REPORT_FILE;
logMessageReport.delete();
verify(CheckLoggingTestClass.class, false);
- List<String> reportLines = Files.readLines(logMessageReport, Charsets.UTF_8);
+ List<String> reportLines = Files.readAllLines(logMessageReport.toPath(), StandardCharsets.UTF_8);
assertEquals(6, reportLines.size());
assertEquals("src/test/java/org/opendaylight/yangtools/checkstyle/CheckLoggingTestClass.java:27:\"foo {} {}\"", reportLines.get(0));
// TODO assertEquals("src/test/java/org/opendaylight/yangtools/checkstyle/CheckLoggingTestClass.java:28:\"foo {} bar {}\"", reportLines.get(1));
*/
package org.opendaylight.yangtools.concepts;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import javax.annotation.Nonnull;
/**
private final T instance;
protected AbstractObjectRegistration(final @Nonnull T instance) {
- this.instance = Preconditions.checkNotNull(instance);
+ this.instance = requireNonNull(instance);
}
@Override
*/
package org.opendaylight.yangtools.concepts;
+import static com.google.common.base.Preconditions.checkArgument;
+
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 int patch;
private SemVer(final int major, final int minor, final int patch) {
- Preconditions.checkArgument(major >= 0);
+ checkArgument(major >= 0);
this.major = major;
- Preconditions.checkArgument(minor >= 0);
+ checkArgument(minor >= 0);
this.minor = minor;
- Preconditions.checkArgument(patch >= 0);
+ checkArgument(patch >= 0);
this.patch = patch;
}
*/
package org.opendaylight.yangtools.concepts;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
* @throws NullPointerException if output is null
*/
public static void writeLong(final DataOutput out, final long value, final int flags) throws IOException {
- Preconditions.checkArgument((flags & 0xFFFFFF0F) == 0, "Invalid flags %s", flags);
+ checkArgument((flags & 0xFFFFFF0F) == 0, "Invalid flags %s", flags);
final int bytes = valueBytes(value);
out.writeByte(bytes | flags);
writeValue(out, value, bytes);
*/
package org.opendaylight.yangtools.objcache;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.yangtools.objcache.impl.StaticObjectCacheBinder;
fa = initialize();
}
- return fa.getObjectCache(Preconditions.checkNotNull(objClass));
+ return fa.getObjectCache(requireNonNull(objClass));
}
}
*/
package org.opendaylight.yangtools.objcache.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.FinalizableReferenceQueue;
import com.google.common.base.FinalizableSoftReference;
-import com.google.common.base.Preconditions;
import com.google.common.cache.Cache;
-import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.ProductAwareBuilder;
private final ProductAwareBuilder<?> builder;
private BuilderKey(final ProductAwareBuilder<?> builder) {
- this.builder = Preconditions.checkNotNull(builder);
+ this.builder = requireNonNull(builder);
}
@Override
private final int hashCode;
public SoftKey(final T referent, final FinalizableReferenceQueue queue) {
- super(Preconditions.checkNotNull(referent), queue);
+ super(requireNonNull(referent), queue);
hashCode = referent.hashCode();
}
private final Cache<SoftKey<?>, Object> cache;
protected AbstractObjectCache(final Cache<SoftKey<?>, Object> cache, final FinalizableReferenceQueue queue) {
- this.queue = Preconditions.checkNotNull(queue);
- this.cache = Preconditions.checkNotNull(cache);
+ this.queue = requireNonNull(queue);
+ this.cache = requireNonNull(cache);
}
protected <T> SoftKey<T> createSoftKey(final T object) {
final SoftKey<T> key = createSoftKey(object);
try {
- return (T) cache.get(key, new Callable<T>() {
- @Override
- public T call() {
- return object;
- }
- });
+ return (T) cache.get(key, () -> object);
} catch (ExecutionException e) {
throw new IllegalStateException("Failed to load value", e);
}
*/
package org.opendaylight.yangtools.objcache.spi;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import javax.annotation.Nonnull;
public abstract class AbstractObjectCacheBinder implements ObjectCacheFactoryBinder {
private final IObjectCacheFactory factory;
protected AbstractObjectCacheBinder(@Nonnull final IObjectCacheFactory factory) {
- this.factory = Preconditions.checkNotNull(factory);
+ this.factory = requireNonNull(factory);
}
@Override
*/
package org.opendaylight.yangtools.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.concepts.Identifier;
/**
private final T value;
public AbstractIdentifier(final T value) {
- this.value = Preconditions.checkNotNull(value);
+ this.value = requireNonNull(value);
}
public final T getValue() {
*/
package org.opendaylight.yangtools.util;
-import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
import com.google.common.base.Joiner;
-import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
-import com.google.common.base.Supplier;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.concurrent.Callable;
+import java.util.function.Supplier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @return Result of supplier invocation.
*/
public static <V> V withClassLoader(final ClassLoader cls, final Supplier<V> function) {
- checkNotNull(cls, "Classloader should not be null");
- checkNotNull(function, "Function should not be null");
+ requireNonNull(cls, "Classloader should not be null");
+ requireNonNull(function, "Function should not be null");
final Thread currentThread = Thread.currentThread();
final ClassLoader oldCls = currentThread.getContextClassLoader();
* @return Result of callable invocation.
*/
public static <V> V withClassLoader(final ClassLoader cls, final Callable<V> function) throws Exception {
- checkNotNull(cls, "Classloader should not be null");
- checkNotNull(function, "Function should not be null");
+ requireNonNull(cls, "Classloader should not be null");
+ requireNonNull(function, "Function should not be null");
final Thread currentThread = Thread.currentThread();
final ClassLoader oldCls = currentThread.getContextClassLoader();
}
public static ParameterizedType findParameterizedType(final Class<?> subclass, final Class<?> genericType) {
- Preconditions.checkNotNull(subclass);
- Preconditions.checkNotNull(genericType);
+ requireNonNull(subclass);
+ requireNonNull(genericType);
for (final Type type : subclass.getGenericInterfaces()) {
if (type instanceof ParameterizedType && genericType.equals(((ParameterizedType) type).getRawType())) {
*/
package org.opendaylight.yangtools.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.UnmodifiableIterator;
import java.io.Serializable;
import java.util.Arrays;
private final E[] array;
ConstantArrayCollection(final E[] array) {
- this.array = Preconditions.checkNotNull(array);
+ this.array = requireNonNull(array);
}
@Override
*/
package org.opendaylight.yangtools.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.AbstractQueue;
import java.util.Collections;
import java.util.Deque;
@Override
@SuppressWarnings("checkstyle:parameterName")
public <T> T[] toArray(final T[] a) {
- return Preconditions.checkNotNull(a);
+ return requireNonNull(a);
}
@Override
*/
package org.opendaylight.yangtools.util;
+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;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.UnmodifiableIterator;
import java.io.IOException;
* is responsible for ensuring its contents remain unmodified.
*/
ImmutableOffsetMap(@Nonnull final Map<K, Integer> offsets, @Nonnull final V[] objects) {
- this.offsets = Preconditions.checkNotNull(offsets);
- this.objects = Preconditions.checkNotNull(objects);
- Preconditions.checkArgument(offsets.size() == objects.length);
+ this.offsets = requireNonNull(offsets);
+ this.objects = requireNonNull(objects);
+ checkArgument(offsets.size() == objects.length);
}
@Nonnull
*/
package org.opendaylight.yangtools.util;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.collect.ImmutableSet;
import java.math.BigDecimal;
import java.math.BigInteger;
* @return true if object is known to be immutable false otherwise.
*/
public static boolean isImmutable(final Object obj) {
- Preconditions.checkArgument(obj != null,"Object should not be null");
+ checkArgument(obj != null,"Object should not be null");
if (obj instanceof Mutable) {
return false;
} else if (obj instanceof Immutable) {
*/
package org.opendaylight.yangtools.util;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import java.util.Collections;
public static MapAdaptor getInstance(final boolean useSingleton, final int copyMaxItems,
final int persistMinItems) {
- Preconditions.checkArgument(copyMaxItems >= 0, "copyMaxItems has to be a non-negative integer");
- Preconditions.checkArgument(persistMinItems >= 0, "persistMinItems has to be a positive integer");
- Preconditions.checkArgument(persistMinItems <= copyMaxItems,
- "persistMinItems must be less than or equal to copyMaxItems");
+ checkArgument(copyMaxItems >= 0, "copyMaxItems has to be a non-negative integer");
+ checkArgument(persistMinItems >= 0, "persistMinItems has to be a positive integer");
+ checkArgument(persistMinItems <= copyMaxItems, "persistMinItems must be less than or equal to copyMaxItems");
return new MapAdaptor(useSingleton, copyMaxItems, persistMinItems);
}
* @return An empty mutable map.
*/
public <K, V> Map<K, V> initialSnapshot(final int expectedSize) {
- Preconditions.checkArgument(expectedSize >= 0);
+ checkArgument(expectedSize >= 0);
if (expectedSize > persistMinItems) {
return new ReadWriteTrieMap<>();
}
*/
package org.opendaylight.yangtools.util;
+import static com.google.common.base.Verify.verify;
+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.base.Verify;
import com.google.common.collect.ImmutableMap;
import java.util.AbstractMap;
import java.util.AbstractSet;
private boolean needClone = true;
MutableOffsetMap(final Map<K, Integer> offsets, final V[] objects, final HashMap<K, V> newKeys) {
- Verify.verify(newKeys.isEmpty());
- this.offsets = Preconditions.checkNotNull(offsets);
- this.objects = Preconditions.checkNotNull(objects);
- this.newKeys = Preconditions.checkNotNull(newKeys);
+ verify(newKeys.isEmpty());
+ this.offsets = requireNonNull(offsets);
+ this.objects = requireNonNull(objects);
+ this.newKeys = requireNonNull(newKeys);
}
@SuppressWarnings("unchecked")
this(offsets, (V[]) new Object[offsets.size()], newKeys);
for (Entry<K, V> e : source.entrySet()) {
- objects[offsets.get(e.getKey())] = Preconditions.checkNotNull(e.getValue());
+ objects[offsets.get(e.getKey())] = requireNonNull(e.getValue());
}
this.needClone = false;
@Override
public final V put(final K key, final V value) {
- Preconditions.checkNotNull(value);
- final Integer offset = offsets.get(Preconditions.checkNotNull(key));
+ requireNonNull(value);
+ final Integer offset = offsets.get(requireNonNull(key));
if (offset != null) {
final Object obj = objects[offset];
@Override
@SuppressWarnings("checkstyle:parameterName")
public boolean add(final Entry<K, V> e) {
- Preconditions.checkNotNull(e.getValue());
- final V p = MutableOffsetMap.this.put(e.getKey(), e.getValue());
- return !e.getValue().equals(p);
+ final V v = requireNonNull(e.getValue());
+ final V p = MutableOffsetMap.this.put(e.getKey(), v);
+ return !v.equals(p);
}
@Override
@Override
public final void remove() {
- Preconditions.checkState(currentKey != null);
+ requireNonNull(currentKey != null);
checkModCount();
final Integer offset = offsets.get(currentKey);
*/
package org.opendaylight.yangtools.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ForwardingMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
private volatile ImmutableTrieMap<K, V> readOnly;
ReadOnlyTrieMap(final MutableTrieMap<K, V> map, final int size) {
- this.readWrite = Preconditions.checkNotNull(map);
+ this.readWrite = requireNonNull(map);
this.size = size;
}
*/
package org.opendaylight.yangtools.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ForwardingMap;
import java.util.Collection;
import java.util.Collections;
}
ReadWriteTrieMap(final MutableTrieMap<K, V> delegate, final int size) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
this.size = size;
}
*/
package org.opendaylight.yangtools.util;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayDeque;
import java.util.Deque;
// Make sure to call this from a finally block
public static void afterConstructor(final Object key) {
final Deque<Entry<?, Object>> stack = STACK.get();
- Preconditions.checkState(stack != null, "No stack allocated when completing %s", key);
+ checkState(stack != null, "No stack allocated when completing %s", key);
final Entry<?, Object> top = stack.pop();
if (stack.isEmpty()) {
STACK.set(null);
}
- Preconditions.checkState(key == top.getKey(), "Expected key %s, have %s", top.getKey(), key);
- Preconditions.checkState(top.getValue() != null, "");
+ checkState(key == top.getKey(), "Expected key %s, have %s", top.getKey(), key);
+ checkState(top.getValue() != null, "");
}
// BEWARE: this method returns incpmpletely-initialized objects (that is the purpose of this class).
for (Entry<?, Object> e : stack) {
// Keys are treated as identities
if (key == e.getKey()) {
- Preconditions.checkState(e.getValue() != null, "Object for %s is not resolved", key);
+ checkState(e.getValue() != null, "Object for %s is not resolved", key);
LOG.debug("Looked up key {}", e.getKey());
return requiredClass.cast(e.getValue());
}
*/
package org.opendaylight.yangtools.util;
+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;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
@SuppressWarnings("unchecked")
SharedSingletonMap(final K key, final V value) {
this.keySet = (SingletonSet<K>) CACHE.getUnchecked(key);
- this.value = Preconditions.checkNotNull(value);
+ this.value = requireNonNull(value);
}
public static <K, V> SharedSingletonMap<K, V> orderedOf(final K key, final V value) {
}
public static <K, V> SharedSingletonMap<K, V> orderedCopyOf(final Map<K, V> map) {
- Preconditions.checkArgument(map.size() == 1);
+ checkArgument(map.size() == 1);
final Entry<K, V> e = map.entrySet().iterator().next();
return new Ordered<>(e.getKey(), e.getValue());
}
public static <K, V> SharedSingletonMap<K, V> unorderedCopyOf(final Map<K, V> map) {
- Preconditions.checkArgument(map.size() == 1);
+ checkArgument(map.size() == 1);
final Entry<K, V> e = map.entrySet().iterator().next();
return new Unordered<>(e.getKey(), e.getValue());
*/
package org.opendaylight.yangtools.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Iterators;
import java.io.Serializable;
import java.util.Collection;
private final E element;
RegularSingletonSet(final E element) {
- this.element = Preconditions.checkNotNull(element);
+ this.element = requireNonNull(element);
}
@Override
*/
package org.opendaylight.yangtools.util;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
break;
}
}
- Preconditions.checkState(!cycle, "Cycle detected in graph around node: " + cycledNode);
+ checkState(!cycle, "Cycle detected in graph around node: " + cycledNode);
}
/**
*/
package org.opendaylight.yangtools.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
private final Collection<E> delegate;
private UnmodifiableCollection(final Collection<E> delegate) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
}
/**
package org.opendaylight.yangtools.util.concurrent;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.ExecutionList;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListenableFutureTask;
private DelegatingAsyncNotifyingListenableFutureTask(final Callable<V> callable,
@Nullable final Executor listenerExecutor) {
super(callable);
- this.listenerExecutor = Preconditions.checkNotNull(listenerExecutor);
+ this.listenerExecutor = requireNonNull(listenerExecutor);
}
private DelegatingAsyncNotifyingListenableFutureTask(final Runnable runnable, @Nullable final V result,
@Nullable final Executor listenerExecutor) {
super(runnable, result);
- this.listenerExecutor = Preconditions.checkNotNull(listenerExecutor);
+ this.listenerExecutor = requireNonNull(listenerExecutor);
}
@Override
private final Executor executor;
DelegatingRunnable(final Runnable delegate, final Executor executor) {
- this.delegate = Preconditions.checkNotNull(delegate);
- this.executor = Preconditions.checkNotNull(executor);
+ this.delegate = requireNonNull(delegate);
+ this.executor = requireNonNull(executor);
}
@Override
package org.opendaylight.yangtools.util.concurrent;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.AbstractListeningExecutorService;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
*/
public AsyncNotifyingListeningExecutorService(final ExecutorService delegate,
@Nullable final Executor listenableFutureExecutor) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
this.listenableFutureExecutor = listenableFutureExecutor;
}
*/
package org.opendaylight.yangtools.util.concurrent;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
super(0, maximumPoolSize, IDLE_TIMEOUT_IN_SEC, TimeUnit.SECONDS,
new ExecutorQueue(maximumQueueSize));
- this.threadPrefix = Preconditions.checkNotNull(threadPrefix);
+ this.threadPrefix = requireNonNull(threadPrefix);
this.maximumQueueSize = maximumQueueSize;
setThreadFactory(new ThreadFactoryBuilder().setDaemon(true)
@Override
public void setRejectedExecutionHandler(final RejectedExecutionHandler handler) {
- Preconditions.checkNotNull(handler);
- rejectedTaskHandler.setDelegateRejectedExecutionHandler(handler);
+ rejectedTaskHandler.setDelegateRejectedExecutionHandler(requireNonNull(handler));
}
@Override
package org.opendaylight.yangtools.util.concurrent;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.atomic.LongAdder;
* @param delegate the backing RejectedExecutionHandler.
*/
public CountingRejectedExecutionHandler(final RejectedExecutionHandler delegate) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
}
@Override
package org.opendaylight.yangtools.util.concurrent;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Supplier;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.ForwardingListenableFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
+import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
@Nonnull final Supplier<Exception> deadlockExceptionSupplier,
@Nullable final Executor listenableFutureExecutor) {
super(delegate, listenableFutureExecutor);
- this.deadlockExceptionFunction = Preconditions.checkNotNull(deadlockExceptionSupplier);
+ this.deadlockExceptionFunction = requireNonNull(deadlockExceptionSupplier);
}
@Override
private SettableBoolean primeDetector() {
final SettableBoolean b = deadlockDetector.get();
- Preconditions.checkState(!b.isSet(), "Detector for {} has already been primed", this);
+ checkState(!b.isSet(), "Detector for {} has already been primed", this);
b.set();
return b;
}
package org.opendaylight.yangtools.util.concurrent;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Function;
-import com.google.common.base.Preconditions;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
* @param exceptionType the exception type to which to translate.
*/
public ExceptionMapper(final String opName, final Class<X> exceptionType) {
- this.exceptionType = Preconditions.checkNotNull(exceptionType);
- this.opName = Preconditions.checkNotNull(opName);
+ this.exceptionType = requireNonNull(exceptionType);
+ this.opName = requireNonNull(opName);
}
/**
package org.opendaylight.yangtools.util.concurrent;
-import com.google.common.base.Function;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.AbstractCheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
+import java.util.function.Function;
import javax.annotation.Nonnull;
/**
private MappingCheckedFuture(final ListenableFuture<V> delegate, final Function<Exception, X> mapper) {
super(delegate);
- this.mapper = Preconditions.checkNotNull(mapper);
+ this.mapper = requireNonNull(mapper);
}
/**
package org.opendaylight.yangtools.util.concurrent;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.ArrayDeque;
import java.util.Collection;
private QueuedNotificationManager(final Executor executor, final BatchedInvoker<L, N> listenerInvoker,
final int maxQueueCapacity, final String name) {
- Preconditions.checkArgument(maxQueueCapacity > 0, "Invalid maxQueueCapacity %s must be > 0", maxQueueCapacity);
- this.executor = Preconditions.checkNotNull(executor);
- this.listenerInvoker = Preconditions.checkNotNull(listenerInvoker);
+ checkArgument(maxQueueCapacity > 0, "Invalid maxQueueCapacity %s must be > 0", maxQueueCapacity);
+ this.executor = requireNonNull(executor);
+ this.listenerInvoker = requireNonNull(listenerInvoker);
this.maxQueueCapacity = maxQueueCapacity;
- this.name = Preconditions.checkNotNull(name);
+ this.name = requireNonNull(name);
}
/**
}
}), maxQueueCapacity, name);
- Preconditions.checkNotNull(listenerInvoker);
+ requireNonNull(listenerInvoker);
}
/**
private final L listener;
ListenerKey(final L listener) {
- this.listener = Preconditions.checkNotNull(listener);
+ this.listener = requireNonNull(listener);
}
L getListener() {
private boolean exiting;
NotificationTask(final ListenerKey<L> listenerKey, final Iterator<N> notifications) {
- this.listenerKey = Preconditions.checkNotNull(listenerKey);
+ this.listenerKey = requireNonNull(listenerKey);
while (notifications.hasNext()) {
queue.offer(notifications.next());
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.util;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
import com.google.common.collect.UnmodifiableIterator;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
final Collection<Integer> testUnmodifiableCollection = UnmodifiableCollection.create(immutableTestList);
assertNotNull(testUnmodifiableCollection);
- final List<Integer> testList = Lists.newArrayList();
- testList.add(1);
- testList.add(2);
- testList.add(3);
- testList.add(4);
- testList.add(5);
-
+ // Note: this cannot be ImmutableList, because UnmodifiableCollection does recognize it and returns it as is,
+ // without converting it to an UnmodifiableCollection -- which is not what we want.
+ final List<Integer> testList = Arrays.asList(1, 2, 3, 4, 5);
final Collection<Integer> testUnmodifiableCollection2 = UnmodifiableCollection.create(testList);
final Iterator<Integer> iterator = testUnmodifiableCollection2.iterator();
import static org.opendaylight.yangtools.util.concurrent.CommonTestUtils.SUBMIT_RUNNABLE;
import static org.opendaylight.yangtools.util.concurrent.CommonTestUtils.SUBMIT_RUNNABLE_WITH_RESULT;
-import com.google.common.base.Supplier;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.junit.After;
import org.junit.Before;
package org.opendaylight.yangtools.yang.common;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import java.util.Arrays;
import java.util.List;
*/
public OperationFailedException(final String message, final Throwable cause,
final RpcError... errors) {
- super(Preconditions.checkNotNull(message), cause);
+ super(requireNonNull(message), cause);
if (errors != null && errors.length > 0) {
errorList = ImmutableList.copyOf(Arrays.asList(errors));
*/
package org.opendaylight.yangtools.yang.common;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil.getRevisionFormat;
-import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.Interner;
import com.google.common.collect.Interners;
}
private static String checkLocalName(final String localName) {
- Preconditions.checkArgument(localName != null, "Parameter 'localName' may not be null.");
- Preconditions.checkArgument(!Strings.isNullOrEmpty(localName),
- "Parameter 'localName' must be a non-empty string.");
+ checkArgument(localName != null, "Parameter 'localName' may not be null.");
+ checkArgument(!Strings.isNullOrEmpty(localName), "Parameter 'localName' must be a non-empty string.");
for (final char c : ILLEGAL_CHARACTERS) {
if (localName.indexOf(c) != -1) {
* @return Instance of QName
*/
public static QName create(final QNameModule qnameModule, final String localName) {
- return new QName(Preconditions.checkNotNull(qnameModule,"module may not be null"), localName);
+ return new QName(requireNonNull(qnameModule, "module may not be null"), localName);
}
/**
*/
package org.opendaylight.yangtools.yang.common;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
private String str;
ForDate(final Date date) {
- this.date = Preconditions.checkNotNull(date);
+ this.date = requireNonNull(date);
}
ForDate(final Date date, final String str) {
- this.date = Preconditions.checkNotNull(date);
- this.str = Preconditions.checkNotNull(str);
+ this.date = requireNonNull(date);
+ this.str = requireNonNull(str);
}
@Override
}
Proxy(final String str) {
- this.str = Preconditions.checkNotNull(str);
+ this.str = requireNonNull(str);
}
@Override
*/
package org.opendaylight.yangtools.yang.common;
+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.Arrays;
import java.util.Map;
private String reference;
YangVersion(final String str, final String reference) {
- this.str = Preconditions.checkNotNull(str);
- this.reference = Preconditions.checkNotNull(reference);
+ this.str = requireNonNull(str);
+ this.reference = requireNonNull(reference);
}
/**
* @throws NullPointerException if the string is null
*/
public static Optional<YangVersion> parse(@Nonnull final String str) {
- return Optional.ofNullable(YANG_VERSION_MAP.get(Preconditions.checkNotNull(str)));
+ return Optional.ofNullable(YANG_VERSION_MAP.get(requireNonNull(str)));
}
/**
*/
package org.opendaylight.yangtools.yang.data.api;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.io.ObjectStreamException;
import java.util.List;
private FixedYangInstanceIdentifier(final ImmutableList<PathArgument> path, final int hash) {
super(hash);
- this.path = Preconditions.checkNotNull(path, "path must not be null.");
+ this.path = requireNonNull(path, "path must not be null.");
}
static FixedYangInstanceIdentifier create(final Iterable<? extends PathArgument> path, final int hash) {
@Nonnull
@Override
public YangInstanceIdentifier getAncestor(final int depth) {
- Preconditions.checkArgument(depth >= 0, "Negative depth is not allowed");
- Preconditions.checkArgument(depth <= path.size(), "Depth %s exceeds maximum depth %s", depth, path.size());
+ checkArgument(depth >= 0, "Negative depth is not allowed");
+ checkArgument(depth <= path.size(), "Depth %s exceeds maximum depth %s", depth, path.size());
if (depth == path.size()) {
return this;
*/
package org.opendaylight.yangtools.yang.data.api;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.UnmodifiableIterator;
import java.util.Iterator;
import java.util.List;
private final List<PathArgument> stack;
StackedPathArguments(@Nonnull final YangInstanceIdentifier base, @Nonnull final List<PathArgument> stack) {
- Verify.verify(!stack.isEmpty());
+ verify(!stack.isEmpty());
this.base = base.getPathArguments();
this.stack = stack;
}
@Override
@SuppressWarnings("checkstyle:parameterName")
public boolean contains(final Object o) {
- final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ final PathArgument srch = (PathArgument) requireNonNull(o);
return stack.contains(srch) || base.contains(srch);
}
@Override
@SuppressWarnings("checkstyle:parameterName")
public int indexOf(final Object o) {
- final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ final PathArgument srch = (PathArgument) requireNonNull(o);
int ret = base.indexOf(srch);
if (ret == -1) {
@Override
@SuppressWarnings("checkstyle:parameterName")
public int lastIndexOf(final Object o) {
- final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ final PathArgument srch = (PathArgument) requireNonNull(o);
final int ret = stack.lastIndexOf(srch);
if (ret != -1) {
*/
package org.opendaylight.yangtools.yang.data.api;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Iterators;
import com.google.common.collect.UnmodifiableIterator;
import java.util.Collection;
private volatile boolean haveSize;
StackedReversePathArguments(final StackedYangInstanceIdentifier identifier) {
- this.identifier = Preconditions.checkNotNull(identifier);
+ this.identifier = requireNonNull(identifier);
}
private static int calculateSize(final YangInstanceIdentifier parent) {
return i + args.size();
}
- Verify.verify(current instanceof StackedYangInstanceIdentifier);
+ verify(current instanceof StackedYangInstanceIdentifier);
current = current.getParent();
}
}
@Override
@SuppressWarnings("checkstyle:parameterName")
public boolean contains(final Object o) {
- final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ final PathArgument srch = (PathArgument) requireNonNull(o);
return Iterators.contains(iterator(), srch);
}
@Override
@SuppressWarnings("checkstyle:parameterName")
public int indexOf(final Object o) {
- final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ final PathArgument srch = (PathArgument) requireNonNull(o);
return super.indexOf(srch);
}
@Override
@SuppressWarnings("checkstyle:parameterName")
public int lastIndexOf(final Object o) {
- final PathArgument srch = (PathArgument) Preconditions.checkNotNull(o);
+ final PathArgument srch = (PathArgument) requireNonNull(o);
int ret = -1;
final Iterator<PathArgument> it = iterator();
private Iterator<PathArgument> tail;
IteratorImpl(final StackedYangInstanceIdentifier identifier) {
- this.identifier = Preconditions.checkNotNull(identifier);
+ this.identifier = requireNonNull(identifier);
}
@Override
tail = args.iterator();
identifier = null;
} else {
- Verify.verify(next instanceof StackedYangInstanceIdentifier);
+ verify(next instanceof StackedYangInstanceIdentifier);
identifier = (StackedYangInstanceIdentifier) next;
}
*/
package org.opendaylight.yangtools.yang.data.api;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import java.io.IOException;
StackedYangInstanceIdentifier(final YangInstanceIdentifier parent, final PathArgument pathArgument,
final int hash) {
super(hash);
- this.parent = Preconditions.checkNotNull(parent);
- this.pathArgument = Preconditions.checkNotNull(pathArgument);
+ this.parent = requireNonNull(parent);
+ this.pathArgument = requireNonNull(pathArgument);
}
@Override
@Nonnull
@Override
public YangInstanceIdentifier getAncestor(final int depth) {
- Preconditions.checkArgument(depth >= 0, "Steps cannot be negative");
+ checkArgument(depth >= 0, "Steps cannot be negative");
// Calculate how far up our FixedYangInstanceIdentifier ancestor is
int stackedDepth = 1;
// Calculate our depth and check argument
final int ourDepth = stackedDepth + fixedDepth;
- Preconditions.checkArgument(depth <= ourDepth, "Depth %s exceeds maximum depth %s", depth, ourDepth);
+ checkArgument(depth <= ourDepth, "Depth %s exceeds maximum depth %s", depth, ourDepth);
// Requested depth is covered by the stack, traverse up for specified number of steps
final int toWalk = ourDepth - depth;
final List<PathArgument> stack = new ArrayList<>();
YangInstanceIdentifier current = this;
do {
- Verify.verify(current instanceof StackedYangInstanceIdentifier);
+ verify(current instanceof StackedYangInstanceIdentifier);
final StackedYangInstanceIdentifier stacked = (StackedYangInstanceIdentifier) current;
stack.add(stacked.getLastPathArgument());
current = stacked.getParent();
*/
package org.opendaylight.yangtools.yang.data.api;
+import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import javax.annotation.Nonnull;
while (oit.hasNext()) {
// Ancestor is not really an ancestor
if (!lit.hasNext() || !lit.next().equals(oit.next())) {
- return Optional.absent();
+ return Optional.empty();
}
++common;
return true;
}
- Preconditions.checkArgument(other != null, "other should not be null");
+ checkArgument(other != null, "other should not be null");
final Iterator<PathArgument> lit = getPathArguments().iterator();
final Iterator<PathArgument> oit = other.getPathArguments().iterator();
private transient volatile boolean hashGuard = false;
protected AbstractPathArgument(final QName nodeType) {
- this.nodeType = Preconditions.checkNotNull(nodeType);
+ this.nodeType = requireNonNull(nodeType);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.api;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
+import static java.util.Objects.requireNonNull;
+
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
this.path = new ArrayList<>();
}
- YangInstanceIdentifierBuilder(final
Iterable<PathArgument> prefix, final int hash) {
- this.path = Lists.newArrayList(prefix);
+ YangInstanceIdentifierBuilder(final
List<PathArgument> prefix, final int hash) {
+ this.path = new ArrayList<>(prefix);
this.hash = new HashCodeBuilder<>(hash);
}
@Override
public InstanceIdentifierBuilder node(final PathArgument arg) {
- return addArgument(Preconditions.checkNotNull(arg));
+ return addArgument(requireNonNull(arg));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import com.google.common.base.Optional;
import java.util.Collection;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
* @param child
* Path argument identifying child node
* @return Optional with child node if child exists.
- * {@link Optional#absent()} if child does not exists.
+ * {@link Optional#empty()} if child does not exists.
*/
Optional<V> getChild(K child);
}
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import com.google.common.collect.Maps;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
public static Optional<NormalizedNode<?, ?>> findNode(final YangInstanceIdentifier rootPath,
final NormalizedNode<?, ?> rootNode, final YangInstanceIdentifier childPath) {
final Optional<YangInstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
- return relativePath.isPresent() ? findNode(rootNode, relativePath.get()) : Optional.absent();
+ return relativePath.isPresent() ? findNode(rootNode, relativePath.get()) : Optional.empty();
}
public static Optional<NormalizedNode<?, ?>> findNode(final Optional<NormalizedNode<?, ?>> parent,
final Iterable<PathArgument> relativePath) {
- checkNotNull(parent, "Parent must not be null");
- checkNotNull(relativePath, "Relative path must not be null");
+ requireNonNull(parent, "Parent must not be null");
+ requireNonNull(relativePath, "Relative path must not be null");
Optional<NormalizedNode<?, ?>> currentNode = parent;
final Iterator<PathArgument> pathIterator = relativePath.iterator();
public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent,
final Iterable<PathArgument> relativePath) {
- return findNode(Optional.fromNullable(parent), relativePath);
+ return findNode(Optional.ofNullable(parent), relativePath);
}
public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent,
public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> tree,
final YangInstanceIdentifier path) {
- checkNotNull(tree, "Tree must not be null");
- checkNotNull(path, "Path must not be null");
+ requireNonNull(tree, "Tree must not be null");
+ requireNonNull(path, "Path must not be null");
return findNode(Optional.of(tree), path.getPathArguments());
}
public static Optional<NormalizedNode<?, ?>> getDirectChild(final NormalizedNode<?, ?> node,
final PathArgument pathArg) {
if (node instanceof LeafNode<?> || node instanceof LeafSetEntryNode<?>) {
- return Optional.absent();
+ return Optional.empty();
} else if (node instanceof DataContainerNode<?>) {
return (Optional) ((DataContainerNode<?>) node).getChild(pathArg);
} else if (node instanceof MapNode && pathArg instanceof NodeIdentifierWithPredicates) {
} else if (node instanceof LeafSetNode<?>) {
return (Optional) ((LeafSetNode<?>) node).getChild((NodeWithValue) pathArg);
}
- return Optional.absent();
+ return Optional.empty();
}
/**
*/
package org.opendaylight.yangtools.yang.data.api.schema.stream;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-
/**
* Event Stream Writer based on Normalized Node tree representation
*
* @throws NullPointerException if the argument is null
*/
default void nextDataSchemaNode(@Nonnull final DataSchemaNode schema) {
- Preconditions.checkNotNull(schema);
+ requireNonNull(schema);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.api.schema.stream;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import java.util.Collection;
+import java.util.Optional;
import java.util.Set;
import javax.xml.stream.XMLStreamReader;
import org.opendaylight.yangtools.yang.common.QName;
private final NormalizedNodeStreamWriter writer;
protected NormalizedNodeWriter(final NormalizedNodeStreamWriter writer) {
- this.writer = Preconditions.checkNotNull(writer);
+ this.writer = requireNonNull(writer);
}
protected final NormalizedNodeStreamWriter getWriter() {
* @return Best estimate of the collection size required to hold all the children.
*/
protected static int childSizeHint(final Iterable<?> children) {
- return (children instanceof Collection) ? ((Collection<?>) children).size() : UNKNOWN_SIZE;
+ return children instanceof Collection ? ((Collection<?>) children).size() : UNKNOWN_SIZE;
}
protected boolean wasProcessAsSimpleNode(final NormalizedNode<?, ?> node) throws IOException {
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import com.google.common.base.Optional;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
+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.Iterator;
import javax.annotation.Nonnull;
private final Iterator<DataTreeCandidateNode> iterator;
AbstractNodeIterator(final Iterator<DataTreeCandidateNode> iterator) {
- this.iterator = Preconditions.checkNotNull(iterator);
+ this.iterator = requireNonNull(iterator);
}
AbstractNodeIterator next(final DataTreeModificationCursor cursor) {
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.Iterator;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
NodeIterator(@Nullable final NodeIterator parent, @Nonnull final YangInstanceIdentifier path,
@Nonnull final Iterator<DataTreeCandidateNode> iterator) {
- this.iterator = Preconditions.checkNotNull(iterator);
- this.path = Preconditions.checkNotNull(path);
+ this.iterator = requireNonNull(iterator);
+ this.path = requireNonNull(path);
this.parent = parent;
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
DataTreeConfiguration(final TreeType treeType, final YangInstanceIdentifier rootPath, final boolean uniqueIndexes,
final boolean mandatoryNodesValidation) {
- this.treeType = Preconditions.checkNotNull(treeType);
- this.rootPath = Preconditions.checkNotNull(rootPath);
+ this.treeType = requireNonNull(treeType);
+ this.rootPath = requireNonNull(rootPath);
this.uniqueIndexes = uniqueIndexes;
this.mandatoryNodesValidation = mandatoryNodesValidation;
}
}
public static DataTreeConfiguration getDefault(final TreeType treeType) {
- Preconditions.checkNotNull(treeType);
- switch (treeType) {
+ switch (requireNonNull(treeType)) {
case CONFIGURATION:
return DEFAULT_CONFIGURATION;
case OPERATIONAL:
private boolean mandatoryNodesValidation;
public Builder(final TreeType treeType) {
- this.treeType = Preconditions.checkNotNull(treeType);
+ this.treeType = requireNonNull(treeType);
this.rootPath = YangInstanceIdentifier.EMPTY;
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
package org.opendaylight.yangtools.yang.data.api.schema.tree;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
public DataValidationFailedException(final YangInstanceIdentifier path, final String message,
final Throwable cause) {
super(message, cause);
- this.path = Preconditions.checkNotNull(path);
+ this.path = requireNonNull(path);
}
/**
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
private final DataTreeCandidateNode rootNode;
DefaultDataTreeCandidate(final YangInstanceIdentifier rootPath, final DataTreeCandidateNode rootNode) {
- this.rootPath = Preconditions.checkNotNull(rootPath);
- this.rootNode = Preconditions.checkNotNull(rootNode);
+ this.rootPath = requireNonNull(rootPath);
+ this.rootNode = requireNonNull(rootNode);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
private final PathArgument identifier;
EmptyDataTreeCandidateNode(final PathArgument identifier) {
- this.identifier = Preconditions.checkNotNull(identifier, "Identifier should not be null");
+ this.identifier = requireNonNull(identifier, "Identifier should not be null");
}
@Nonnull
@Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataAfter() {
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
- return Optional.absent();
+ return Optional.empty();
}
}
\ No newline at end of file
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* the {@link NormalizedNode} passed to it at creation time were freshly written.
*/
final class NormalizedNodeDataTreeCandidateNode implements DataTreeCandidateNode {
- /**
- * Convenience function for functional transformation of {@link NormalizedNode} into
- * a {@link DataTreeCandidateNode}.
- */
- private static final Function<NormalizedNode<?, ?>, DataTreeCandidateNode> FACTORY_FUNCTION =
- input -> input == null ? null : new NormalizedNodeDataTreeCandidateNode(input);
private final NormalizedNode<?, ?> data;
/**
* @param data Backing {@link NormalizedNode} data.
*/
NormalizedNodeDataTreeCandidateNode(@Nonnull final NormalizedNode<?, ?> data) {
- this.data = Preconditions.checkNotNull(data);
+ this.data = requireNonNull(data);
}
@Nonnull
@Override
public Collection<DataTreeCandidateNode> getChildNodes() {
if (data instanceof NormalizedNodeContainer) {
- return Collections2.transform(((NormalizedNodeContainer<?, ?, ?>) data).getValue(), FACTORY_FUNCTION);
+ return Collections2.transform(((NormalizedNodeContainer<?, ?, ?>) data).getValue(),
+ input -> input == null ? null : new NormalizedNodeDataTreeCandidateNode(input));
}
return ImmutableList.of();
}
if (data instanceof NormalizedNodeContainer) {
@SuppressWarnings({ "rawtypes", "unchecked" })
final Optional<? extends NormalizedNode<?, ?>> child = ((NormalizedNodeContainer)data).getChild(identifier);
- return FACTORY_FUNCTION.apply(child.orNull());
+ return child.map(input -> new NormalizedNodeDataTreeCandidateNode(input)).orElse(null);
}
return null;
}
@Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
- return Optional.absent();
+ return Optional.empty();
}
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
* Returns a direct child of the node.
*
* @param child Identifier of child
- * @return Optional with node if the child is existing, {@link Optional#absent()} otherwise.
+ * @return Optional with node if the child is existing, {@link Optional#empty()} otherwise.
*/
Optional<C> getChild(PathArgument child);
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
+import static com.google.common.base.Verify.verify;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Predicate;
-import com.google.common.base.Predicates;
-import com.google.common.base.Verify;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.Iterator;
import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.function.Predicate;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
* Store tree node type.
* @param tree Data Tree
* @param path Path to the node
- * @return Optional with node if the node is present in tree, {@link Optional#absent()} otherwise.
+ * @return Optional with node if the node is present in tree, {@link Optional#empty()} otherwise.
*/
public static <T extends StoreTreeNode<T>> Optional<T> findNode(final T tree, final YangInstanceIdentifier path) {
Optional<T> current = Optional.of(tree);
*/
public static <T extends StoreTreeNode<T>> Entry<YangInstanceIdentifier, T> findClosest(final T tree,
final YangInstanceIdentifier path) {
- return findClosestsOrFirstMatch(tree, path, Predicates.alwaysFalse());
+ return findClosestsOrFirstMatch(tree, path, input -> false);
}
public static <T extends StoreTreeNode<T>> Entry<YangInstanceIdentifier, T> findClosestsOrFirstMatch(final T tree,
int nesting = 0;
Iterator<PathArgument> pathIter = path.getPathArguments().iterator();
- while (current.isPresent() && pathIter.hasNext() && !predicate.apply(current.get())) {
+ while (current.isPresent() && pathIter.hasNext() && !predicate.test(current.get())) {
parent = current;
current = current.get().getChild(pathIter.next());
nesting++;
* for current.isPresent() failed, which it cannot, as current is always
* present. At any rate we verify state just to be on the safe side.
*/
- Verify.verify(nesting > 0);
+ verify(nesting > 0);
return new SimpleImmutableEntry<>(path.getAncestor(nesting - 1), parent.get());
}
if (parent.isPresent()) {
return parent.get().getChild(child);
}
- return Optional.absent();
+ return Optional.empty();
}
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private final DataTreeModification delegate;
private SynchronizedDataTreeModification(final DataTreeModification delegate) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
}
public static DataTreeModification create(final DataTreeModification delegate) {
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
protected final Optional<TreeNode> getChildFromData(final PathArgument childId) {
// We do not cache the instantiated node as it is dirt cheap
- return Optional.fromNullable(getChildFromData(castData(), childId, getVersion()));
+ return Optional.ofNullable(getChildFromData(castData(), childId, getVersion()));
}
static TreeNode getChildFromData(final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> data,
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import java.util.Map;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
protected AbstractModifiedContainerNode(final NormalizedNode<?, ?> data, final Version version,
final Map<PathArgument, TreeNode> children, final Version subtreeVersion) {
super(data, version);
- this.subtreeVersion = Preconditions.checkNotNull(subtreeVersion);
- this.children = Preconditions.checkNotNull(children);
+ this.subtreeVersion = requireNonNull(subtreeVersion);
+ this.children = requireNonNull(children);
}
protected final TreeNode getModifiedChild(final PathArgument childId) {
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import java.util.Map;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
this.data = parent.getData();
this.version = parent.getVersion();
this.subtreeVersion = parent.getSubtreeVersion();
- this.children = Preconditions.checkNotNull(children);
+ this.children = requireNonNull(children);
}
protected final Version getVersion() {
@Override
public final void setSubtreeVersion(final Version subtreeVersion) {
- this.subtreeVersion = Preconditions.checkNotNull(subtreeVersion);
+ this.subtreeVersion = requireNonNull(subtreeVersion);
}
@Override
@Override
public final void setData(final NormalizedNode<?, ?> data) {
- this.data = Preconditions.checkNotNull(data);
+ this.data = requireNonNull(data);
}
@Override
final Map<PathArgument, TreeNode> newChildren = MapAdaptor.getDefaultInstance().optimize(children);
final int dataSize = getData().getValue().size();
if (dataSize != newChildren.size()) {
- Verify.verify(dataSize > newChildren.size(), "Detected %s modified children, data has only %s",
+ verify(dataSize > newChildren.size(), "Detected %s modified children, data has only %s",
newChildren.size(), dataSize);
ret = new LazyContainerNode(data, version, newChildren, subtreeVersion);
} else {
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private final Version version;
protected AbstractTreeNode(final NormalizedNode<?, ?> data, final Version version) {
- this.data = Preconditions.checkNotNull(data);
- this.version = Preconditions.checkNotNull(version);
+ this.data = requireNonNull(data);
+ this.version = requireNonNull(version);
}
@Override
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
import com.google.common.collect.Collections2;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
-import com.google.common.base.Optional;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
return Optional.of(modified);
}
- return Optional.fromNullable(AbstractContainerNode.getChildFromData(getData(), childId, getVersion()));
+ return Optional.ofNullable(AbstractContainerNode.getChildFromData(getData(), childId, getVersion()));
}
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
-import com.google.common.base.Optional;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@Override
public Optional<TreeNode> getChild(final PathArgument childId) {
- return Optional.fromNullable(getModifiedChild(childId));
+ return Optional.ofNullable(getModifiedChild(childId));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
-import com.google.common.base.Optional;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
final class MaterializedMutableContainerNode extends AbstractMutableContainerNode {
@Override
public Optional<TreeNode> getChild(final PathArgument child) {
- return Optional.fromNullable(getModifiedChild(child));
+ return Optional.ofNullable(getModifiedChild(child));
}
}
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
@Override
public Optional<TreeNode> getChild(final PathArgument childId) {
LOG.warn("Attempted to access child {} of value-node {}", childId, this);
- return Optional.absent();
+ return Optional.empty();
}
@Override
package org.opendaylight.yangtools.yang.data.api.schema.xpath;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
+import java.util.Optional;
import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import javax.xml.xpath.XPathExpressionException;
/**
* Evaluate this expression at the specified path in a document. If evaluation succeeds, it will return an
* {@link XPathResult} at some point it the future. If it fails to match anything, it {@link Future#get()} will
- * return {@link Optional#absent()}.
+ * return {@link Optional#empty()}.
*
* <p>
* FIXME: The amount of overhead an implementation can incur on the user as data from the resulting
*/
package org.opendaylight.yangtools.yang.data.api.schema.xpath;
+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.Converter;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableBiMap.Builder;
import com.google.common.collect.Maps;
*/
public static @Nonnull Converter<String, QNameModule> create(final SchemaContext ctx, final Module module) {
// Always check for null ctx
- Preconditions.checkNotNull(ctx, "Schema context may not be null");
+ requireNonNull(ctx, "Schema context may not be null");
// Use immutable map builder for detection of duplicates (which should never occur)
final Builder<String, QNameModule> b = ImmutableBiMap.builder();
for (ModuleImport i : module.getImports()) {
final Module mod = ctx.findModuleByName(i.getModuleName(), i.getRevision());
- Preconditions.checkArgument(mod != null, "Unsatisfied import of %s by module %s", i, module);
+ checkArgument(mod != null, "Unsatisfied import of %s by module %s", i, module);
b.put(i.getPrefix(), mod.getQNameModule());
}
package org.opendaylight.yangtools.yang.data.api.schema.xpath;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.xml.xpath.XPathExpressionException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public interface XPathExpression {
/**
* Evaluate this expression at the specified path in a document. If evaluation succeeds, it will return an
- * {@link XPathResult}. If it fails to match anything, it will return {@link Optional#absent()}. Implementations
+ * {@link XPathResult}. If it fails to match anything, it will return {@link Optional#empty()}. Implementations
* of this method are expected to perform complete evaluation such that accessing data via the resulting
* {@link XPathResult} will not incur large overhead.
*
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.data.api;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
+import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME3), new NodeIdentifier(NODENAME4));
final YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
new NodeIdentifier(NODENAME2));
- final YangInstanceIdentifier id3 = YangInstanceIdentifier.create(Lists.newArrayList(
+ final YangInstanceIdentifier id3 = YangInstanceIdentifier.create(Arrays.asList(
new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2)));
Optional<YangInstanceIdentifier> relative = id1.relativeTo(id2);
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.base.Optional;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
+import java.util.Collections;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
final PathArgument mockedPathArgument = mock(PathArgument.class);
final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
- assertEquals(Optional.absent(), NormalizedNodes.getDirectChild(mockedLeafNode, mockedPathArgument));
+ assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafNode, mockedPathArgument));
final LeafSetEntryNode<?> mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
- assertEquals(Optional.absent(), NormalizedNodes.getDirectChild(mockedLeafSetEntryNode, mockedPathArgument));
+ assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafSetEntryNode, mockedPathArgument));
final DataContainerNode<?> mockedDataContainerNode = mock(DataContainerNode.class);
final ContainerNode mockedContainerNode = mock(ContainerNode.class);
doReturn(Optional.of(mockedMapEntryNode)).when(mockedMapNode).getChild(any(NodeIdentifierWithPredicates.class));
assertEquals(mockedMapEntryNode, NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates)
.get());
- assertEquals(Optional.absent(), NormalizedNodes.getDirectChild(mockedMapNode, mockedPathArgument));
+ assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedMapNode, mockedPathArgument));
final LeafSetNode<?> mockedLeafSetNode = mock(LeafSetNode.class);
final QName leafListQName = QName.create("test-ns", "test-leaf-list");
new NodeIdentifier(node2Qname), new NodeIdentifier(node3QName), new NodeIdentifier(node4Qname));
assertEquals(mockedLeafNode, NormalizedNodes.findNode(rootPath, mockedDataContainerNode, childPath).get());
- assertEquals(Optional.absent(), NormalizedNodes.findNode(childPath, mockedDataContainerNode, rootPath));
+ assertEquals(Optional.empty(), NormalizedNodes.findNode(childPath, mockedDataContainerNode, rootPath));
final Optional<YangInstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
final PathArgument[] pathArguments = relativePath.get().getPathArguments().toArray(new PathArgument[2]);
final AugmentationNode mockedAugmentationNode = mock(AugmentationNode.class);
final QName listQName = QName.create("test-ns", "2016-09-16", "list-node");
- final AugmentationIdentifier augNodeId = new AugmentationIdentifier(Sets.newHashSet(listQName));
+ final AugmentationIdentifier augNodeId = new AugmentationIdentifier(Collections.singleton(listQName));
doReturn(augNodeId).when(mockedAugmentationNode).getIdentifier();
final MapNode mockedMapNode = mock(MapNode.class);
final NodeIdentifier listNodeId = new NodeIdentifier(listQName);
doReturn(listNodeId).when(mockedMapNode).getIdentifier();
- doReturn(Lists.newArrayList(mockedMapNode)).when(mockedAugmentationNode).getValue();
+ doReturn(Collections.singletonList(mockedMapNode)).when(mockedAugmentationNode).getValue();
final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
final NodeIdentifierWithPredicates listEntryNodeId = new NodeIdentifierWithPredicates(listQName,
leafNodeQName, "key-leaf-value");
doReturn(listEntryNodeId).when(mockedMapEntryNode).getIdentifier();
- doReturn(Lists.newArrayList(mockedMapEntryNode)).when(mockedMapNode).getValue();
+ doReturn(Collections.singletonList(mockedMapEntryNode)).when(mockedMapNode).getValue();
- doReturn(Lists.newArrayList(mockedLeafNode)).when(mockedMapEntryNode).getValue();
+ doReturn(Collections.singletonList(mockedLeafNode)).when(mockedMapEntryNode).getValue();
stringTree = NormalizedNodes.toStringTree(mockedAugmentationNode);
assertNotNull(stringTree);
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
+import java.util.Optional;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
doReturn(new NodeIdentifierWithPredicates(myKeyedList, myKeyLeaf, "list-key-value-1"))
.when(mockedMapEntryNode).getIdentifier();
- doReturn(Optional.absent()).when(mockedMapEntryNode).getChild(any(NodeIdentifier.class));
+ doReturn(Optional.empty()).when(mockedMapEntryNode).getChild(any(NodeIdentifier.class));
assertNotNull(orderedNormalizedNodeWriter.write(mockedMapEntryNode));
final UnkeyedListEntryNode mockedUnkeyedListEntryNode = mock(UnkeyedListEntryNode.class);
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
-import com.google.common.collect.Lists;
+import com.google.common.collect.ImmutableList;
import java.util.Collection;
+import java.util.Collections;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedChildNode3).getModificationType();
final DataTreeCandidateNode mockedChildNode3ChildNode = mock(DataTreeCandidateNode.class);
doReturn(ModificationType.DELETE).when(mockedChildNode3ChildNode).getModificationType();
- doReturn(Lists.newArrayList(mockedChildNode3ChildNode)).when(mockedChildNode3).getChildNodes();
+ doReturn(Collections.singletonList(mockedChildNode3ChildNode)).when(mockedChildNode3).getChildNodes();
- final Collection<DataTreeCandidateNode> childNodes = Lists.newArrayList(mockedChildNode1, mockedChildNode2,
+ final Collection<DataTreeCandidateNode> childNodes = ImmutableList.of(mockedChildNode1, mockedChildNode2,
mockedChildNode3);
doReturn(childNodes).when(mockedDataTreeCandidateNode).getChildNodes();
final DataTreeCandidateNode mockedChildNode1 = mock(DataTreeCandidateNode.class);
doReturn(ModificationType.DELETE).when(mockedChildNode1).getModificationType();
- doReturn(Lists.newArrayList(mockedChildNode1)).when(mockedDataTreeCandidateNode).getChildNodes();
+ doReturn(Collections.singletonList(mockedChildNode1)).when(mockedDataTreeCandidateNode).getChildNodes();
DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, mockedRootPath, mockedDataTreeCandidateNode);
verify(mockedCursor, times(1)).enter(any(PathArgument.class));
final DataTreeCandidateNode mockedChildNode1 = mock(DataTreeCandidateNode.class);
doReturn(ModificationType.DELETE).when(mockedChildNode1).getModificationType();
- doReturn(Lists.newArrayList(mockedChildNode1)).when(mockedDataTreeCandidateNode).getChildNodes();
+ doReturn(Collections.singletonList(mockedChildNode1)).when(mockedDataTreeCandidateNode).getChildNodes();
DataTreeCandidateNodes.applyRootToCursor(mockedCursor, mockedDataTreeCandidateNode);
verify(mockedCursor, times(1)).delete(any(PathArgument.class));
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
-import com.google.common.collect.Lists;
+import com.google.common.collect.ImmutableList;
import java.util.Collection;
+import java.util.Collections;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
final PathArgument mockedPathArgument31 = mock(PathArgument.class);
doReturn(mockedPathArgument3).when(mockedChildNode3).getIdentifier();
doReturn(mockedPathArgument31).when(mockedChildNode3ChildNode).getIdentifier();
- doReturn(Lists.newArrayList(mockedChildNode3ChildNode)).when(mockedChildNode3).getChildNodes();
+ doReturn(Collections.singletonList(mockedChildNode3ChildNode)).when(mockedChildNode3).getChildNodes();
- final Collection<DataTreeCandidateNode> childNodes = Lists.newArrayList(mockedChildNode1, mockedChildNode2,
+ final Collection<DataTreeCandidateNode> childNodes = ImmutableList.of(mockedChildNode1, mockedChildNode2,
mockedChildNode3);
doReturn(childNodes).when(mockedDataTreeCandidateNode).getChildNodes();
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.base.Optional;
-import com.google.common.collect.Lists;
+import java.util.Arrays;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
assertEquals(ModificationType.WRITE, normalizedNodeDataTreeCandidateNode.getModificationType());
assertEquals(Optional.of(mockedNormalizedNode), normalizedNodeDataTreeCandidateNode.getDataAfter());
- assertEquals(Optional.absent(), normalizedNodeDataTreeCandidateNode.getDataBefore());
+ assertEquals(Optional.empty(), normalizedNodeDataTreeCandidateNode.getDataBefore());
final NormalizedNodeContainer mockedNormalizedNodeContainer = mock(NormalizedNodeContainer.class);
final NormalizedNodeDataTreeCandidateNode normalizedNodeDataTreeCandidateNode2 = new
NormalizedNodeDataTreeCandidateNode(mockedNormalizedNodeContainer);
final NormalizedNode<?, ?> mockedChildNormNode1 = mock(NormalizedNode.class);
final NormalizedNode<?, ?> mockedChildNormNode2 = mock(NormalizedNode.class);
- final Collection<NormalizedNode<?, ?>> mockedChildNodes = Lists.newArrayList(mockedChildNormNode1,
+ final Collection<NormalizedNode<?, ?>> mockedChildNodes = Arrays.asList(mockedChildNormNode1,
mockedChildNormNode2, null);
doReturn(mockedChildNodes).when(mockedNormalizedNodeContainer).getValue();
final Collection<DataTreeCandidateNode> childNodes2 = normalizedNodeDataTreeCandidateNode2.getChildNodes();
assertEquals(3, childNodes2.size());
- doReturn(Optional.absent()).when(mockedNormalizedNodeContainer).getChild(any(PathArgument.class));
+ doReturn(Optional.empty()).when(mockedNormalizedNodeContainer).getChild(any(PathArgument.class));
assertNull(normalizedNodeDataTreeCandidateNode2.getModifiedChild(mockedPathArgument));
doReturn(Optional.of(mockedChildNormNode1)).when(mockedNormalizedNodeContainer).getChild(
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yangtools.yang.data.impl.codec.DataStringCodec;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
private final DataStringCodec<T> codec;
AbstractJSONCodec(final DataStringCodec<T> codec) {
- this.codec = Preconditions.checkNotNull(codec);
+ this.codec = requireNonNull(codec);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import org.opendaylight.yangtools.yang.common.QName;
private final QNameModule parentModule;
IdentityrefJSONCodec(final SchemaContext context, final QNameModule parentModule) {
- this.schemaContext = Preconditions.checkNotNull(context);
- this.parentModule = Preconditions.checkNotNull(parentModule);
+ this.schemaContext = requireNonNull(context);
+ this.parentModule = requireNonNull(parentModule);
}
@Override
}
final Module module = schemaContext.findModuleByName(prefix, null);
- Preconditions.checkArgument(module != null, "Could not find module %s", prefix);
+ checkArgument(module != null, "Could not find module %s", prefix);
return module.getQNameModule();
});
}
public void writeValue(final JsonWriter writer, final QName value) throws IOException {
final String str = QNameCodecUtil.encodeQName(value, uri -> {
final Module module = schemaContext.findModuleByNamespaceAndRevision(uri.getNamespace(), null);
- Preconditions.checkArgument(module != null, "Cannot find module for %s", uri);
+ checkArgument(module != null, "Cannot find module for %s", uri);
return module.getName();
});
writer.value(str);
package org.opendaylight.yangtools.yang.data.codec.gson;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Stopwatch;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.List;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.impl.codec.AbstractIntegerStringCodec;
import org.opendaylight.yangtools.yang.data.impl.codec.BinaryStringCodec;
* @throws NullPointerException if context is null
*/
public static Optional<JSONCodecFactory> getPrecomputedIfAvailable(final SchemaContext context) {
- return Optional.fromNullable(PRECOMPUTED.getIfPresent(context));
+ return Optional.ofNullable(PRECOMPUTED.getIfPresent(context));
}
/**
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream.ANYXML_ARRAY_ELEMENT_ID;
import static org.w3c.dom.Node.ELEMENT_NODE;
import static org.w3c.dom.Node.TEXT_NODE;
-import com.google.common.base.Preconditions;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
JSONNormalizedNodeStreamWriter(final JSONCodecFactory codecFactory, final SchemaPath path, final JsonWriter writer,
final JSONStreamWriterRootContext rootContext) {
- this.writer = Preconditions.checkNotNull(writer);
- this.codecs = Preconditions.checkNotNull(codecFactory);
+ this.writer = requireNonNull(writer);
+ this.codecs = requireNonNull(codecFactory);
this.tracker = SchemaTracker.create(codecFactory.getSchemaContext(), path);
- this.context = Preconditions.checkNotNull(rootContext);
+ this.context = requireNonNull(rootContext);
}
/**
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
final URI ns = qname.getNamespace();
if (!ns.equals(getNamespace())) {
final Module module = schema.findModuleByNamespaceAndRevision(ns, null);
- Preconditions.checkArgument(module != null, "Could not find module for namespace {}", ns);
+ checkArgument(module != null, "Could not find module for namespace {}", ns);
sb.append(module.getName());
sb.append(':');
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.gson.stream.JsonWriter;
/**
*/
final class JSONStreamWriterInvisibleContext extends JSONStreamWriterURIContext {
JSONStreamWriterInvisibleContext(final JSONStreamWriterContext parent) {
- super(Preconditions.checkNotNull(parent), parent.getNamespace());
+ super(requireNonNull(parent), parent.getNamespace());
}
@Override
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
*/
final class JSONStreamWriterListContext extends JSONStreamWriterQNameContext {
protected JSONStreamWriterListContext(final JSONStreamWriterContext parent, final NodeIdentifier id) {
- super(Preconditions.checkNotNull(parent), id.getNodeType(), false);
+ super(requireNonNull(parent), id.getNodeType(), false);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
class JSONStreamWriterObjectContext extends JSONStreamWriterQNameContext {
protected JSONStreamWriterObjectContext(final JSONStreamWriterContext parent, final PathArgument arg,
final boolean mandatory) {
- super(Preconditions.checkNotNull(parent), arg.getNodeType(), mandatory);
+ super(requireNonNull(parent), arg.getNodeType(), mandatory);
}
@Override
protected void emitEnd(final JsonWriter writer) throws IOException {
writer.endObject();
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
import java.net.URI;
-
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
abstract class JSONStreamWriterQNameContext extends JSONStreamWriterContext {
private final QName qname;
- protected JSONStreamWriterQNameContext(final JSONStreamWriterContext parent, final QName qname,
- final boolean mandatory) {
+ JSONStreamWriterQNameContext(final JSONStreamWriterContext parent, final QName qname, final boolean mandatory) {
super(parent, mandatory);
- this.qname = Preconditions.checkNotNull(qname);
+ this.qname = requireNonNull(qname);
}
/**
protected final URI getNamespace() {
return qname.getNamespace();
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
private final SchemaContext context;
JSONStringInstanceIdentifierCodec(final SchemaContext context, final JSONCodecFactory jsonCodecFactory) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
this.dataContextTree = DataSchemaContextTree.from(context);
- this.codecFactory = Preconditions.checkNotNull(jsonCodecFactory);
+ this.codecFactory = requireNonNull(jsonCodecFactory);
}
@Override
@Override
protected Object deserializeKeyValue(final DataSchemaNode schemaNode, final String value) {
- Preconditions.checkNotNull(schemaNode, "schemaNode cannot be null");
- Preconditions.checkArgument(schemaNode instanceof LeafSchemaNode, "schemaNode must be of type LeafSchemaNode");
+ requireNonNull(schemaNode, "schemaNode cannot be null");
+ checkArgument(schemaNode instanceof LeafSchemaNode, "schemaNode must be of type LeafSchemaNode");
final JSONCodec<?> objectJSONCodec = codecFactory.codecFor((LeafSchemaNode) schemaNode);
return objectJSONCodec.parseValue(null, value);
}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.gson.JsonIOException;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSyntaxException;
private JsonParserStream(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
final JSONCodecFactory codecs, final DataSchemaNode parentNode) {
- this.schema = Preconditions.checkNotNull(schemaContext);
- this.writer = Preconditions.checkNotNull(writer);
- this.codecs = Preconditions.checkNotNull(codecs);
+ this.schema = requireNonNull(schemaContext);
+ this.writer = requireNonNull(writer);
+ this.codecs = requireNonNull(codecs);
this.parentNode = parentNode;
}
if (parentNode instanceof RpcDefinition) {
return new JsonParserStream(writer, schemaContext, new RpcAsContainer((RpcDefinition) parentNode));
}
- Preconditions.checkArgument(parentNode instanceof DataSchemaNode, "Instance of DataSchemaNode class awaited.");
+ checkArgument(parentNode instanceof DataSchemaNode, "Instance of DataSchemaNode class awaited.");
return new JsonParserStream(writer, schemaContext, (DataSchemaNode) parentNode);
}
final Deque<DataSchemaNode> childDataSchemaNodes =
ParserStreamUtils.findSchemaNodeByNameAndNamespace(parentSchema, localName,
getCurrentNamespace());
- Preconditions.checkState(!childDataSchemaNodes.isEmpty(),
+ checkState(!childDataSchemaNodes.isEmpty(),
"Schema for node with name %s and namespace %s does not exist.", localName,
getCurrentNamespace());
}
private void setValue(final AbstractNodeDataWithSchema parent, final String value) {
- Preconditions.checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type",
+ checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type",
parent.getSchema().getQName());
final SimpleNodeDataWithSchema parentSimpleNode = (SimpleNodeDataWithSchema) parent;
- Preconditions.checkArgument(parentSimpleNode.getValue() == null, "Node '%s' has already set its value to '%s'",
+ checkArgument(parentSimpleNode.getValue() == null, "Node '%s' has already set its value to '%s'",
parentSimpleNode.getSchema().getQName(), parentSimpleNode.getValue());
final Object translatedValue = translateValueByType(value, parentSimpleNode.getSchema());
}
private Object translateValueByType(final String value, final DataSchemaNode node) {
- Preconditions.checkArgument(node instanceof TypedSchemaNode);
+ checkArgument(node instanceof TypedSchemaNode);
return codecs.codecFor((TypedSchemaNode) node).parseValue(null, value);
}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
SingleType(final Class<T> dataClass, final List<JSONCodec<?>> codecs) {
super(codecs);
- this.dataClass = Preconditions.checkNotNull(dataClass);
+ this.dataClass = requireNonNull(dataClass);
}
@Override
static UnionJSONCodec<?> create(final UnionTypeDefinition type, final List<JSONCodec<?>> codecs) {
final Iterator<JSONCodec<?>> it = codecs.iterator();
- Verify.verify(it.hasNext(), "Union %s has no subtypes", type);
+ verify(it.hasNext(), "Union %s has no subtypes", type);
Class<?> dataClass = it.next().getDataType();
while (it.hasNext()) {
import static org.junit.Assert.fail;
import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.loadTextFile;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import com.google.gson.stream.JsonReader;
import java.io.IOException;
import java.io.StringReader;
import java.net.URISyntaxException;
+import java.util.Optional;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
import com.google.gson.stream.JsonReader;
import java.io.IOException;
import java.io.StringReader;
import java.net.URISyntaxException;
+import java.util.Optional;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.loadTextFile;
-import com.google.common.base.Optional;
import com.google.gson.stream.JsonReader;
import java.io.IOException;
import java.io.StringReader;
import java.net.URISyntaxException;
+import java.util.Optional;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.containerBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
-import com.google.common.collect.Sets;
import com.google.gson.stream.JsonReader;
import java.io.IOException;
import java.io.StringReader;
import java.net.URISyntaxException;
+import java.util.Collections;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
public void emptyTypeTest() throws IOException, URISyntaxException {
final String inputJson = loadTextFile("/complexjson/type-empty.json");
final ContainerNode awaitedStructure = containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(CONT_1))
+ .withNodeIdentifier(new NodeIdentifier(CONT_1))
.addChild(leafNode(EMPTY_LEAF, null))
.build();
final QName containerQName = QName.create(augmentChoice1QName, "case11-choice-case-container");
final QName leafQName = QName.create(augmentChoice1QName, "case11-choice-case-leaf");
- final YangInstanceIdentifier.AugmentationIdentifier aug1Id =
- new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(augmentChoice1QName));
- final YangInstanceIdentifier.AugmentationIdentifier aug2Id =
- new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(augmentChoice2QName));
- final YangInstanceIdentifier.NodeIdentifier augmentChoice1Id =
- new YangInstanceIdentifier.NodeIdentifier(augmentChoice1QName);
- final YangInstanceIdentifier.NodeIdentifier augmentChoice2Id =
- new YangInstanceIdentifier.NodeIdentifier(augmentChoice2QName);
- final YangInstanceIdentifier.NodeIdentifier containerId =
- new YangInstanceIdentifier.NodeIdentifier(containerQName);
+ final AugmentationIdentifier aug1Id = new AugmentationIdentifier(Collections.singleton(augmentChoice1QName));
+ final AugmentationIdentifier aug2Id = new AugmentationIdentifier(Collections.singleton(augmentChoice2QName));
+ final NodeIdentifier augmentChoice1Id = new NodeIdentifier(augmentChoice1QName);
+ final NodeIdentifier augmentChoice2Id = new NodeIdentifier(augmentChoice2QName);
+ final NodeIdentifier containerId = new NodeIdentifier(containerQName);
final NormalizedNode<?, ?> cont1Normalized =
- containerBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(parentNode.getQName()))
+ containerBuilder().withNodeIdentifier(new NodeIdentifier(parentNode.getQName()))
.withChild(augmentationBuilder().withNodeIdentifier(aug1Id)
.withChild(choiceBuilder().withNodeIdentifier(augmentChoice1Id)
.withChild(augmentationBuilder().withNodeIdentifier(aug2Id)
import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.childPrimitive;
import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.resolveCont1;
-import com.google.common.collect.Sets;
+import com.google.common.collect.ImmutableSet;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonNull;
final JsonArray lflst11 = childArray(cont1, "complexjson:lflst11", "lflst11");
assertNotNull(lflst11);
- final HashSet<Object> lflst11Values = Sets.newHashSet();
+ final HashSet<Object> lflst11Values = new HashSet<>();
for (final JsonElement jsonElement : lflst11) {
assertTrue(jsonElement instanceof JsonPrimitive);
lflst11Values.add(jsonElement.getAsString());
}
- assertEquals(Sets.newHashSet("lflst11 value2\r\nanother line 2", "lflst11 value1\nanother line 1"),
+ assertEquals(ImmutableSet.of("lflst11 value2\r\nanother line 2", "lflst11 value1\nanother line 1"),
lflst11Values);
}
final JsonArray lflst11 = childArray(cont1, "complexjson:lflst11", "lflst11");
assertNotNull(lflst11);
- final HashSet<Object> lflst11Values = Sets.newHashSet();
+ final HashSet<Object> lflst11Values = new HashSet<>();
for (final JsonElement jsonElement : lflst11) {
assertTrue(jsonElement instanceof JsonPrimitive);
lflst11Values.add(jsonElement.getAsString());
}
- assertEquals(Sets.newHashSet("lflst11 value2", "lflst11 value1"), lflst11Values);
+ assertEquals(ImmutableSet.of("lflst11 value2", "lflst11 value1"), lflst11Values);
}
@Test
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
+import com.google.common.collect.ImmutableSet;
+import java.util.Arrays;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> cont1 = Builders.containerBuilder();
cont1.withNodeIdentifier(new NodeIdentifier(QName.create("ns:complex:json", "2014-08-11", "cont1")));
- cont1.withValue(Lists.newArrayList(children));
+ cont1.withValue(Arrays.asList(children));
return cont1.build();
}
private static DataContainerChild<? extends PathArgument, ?> externalAugmentC11AWithLf15_11AndLf15_12Node() {
DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> augmentationBuilder = Builders
.augmentationBuilder();
- augmentationBuilder.withNodeIdentifier(new AugmentationIdentifier(Sets.newHashSet(
+ augmentationBuilder.withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(
QName.create("ns:complex:json:augmentation", "2014-08-14", "lf15_11"),
QName.create("ns:complex:json:augmentation", "2014-08-14", "lf15_12"))));
augmentationBuilder.withChild(lf15_11NodeExternal());
final DataContainerChild<? extends PathArgument, ?>... children) {
DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> choc11Builder = Builders.choiceBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create("ns:complex:json", "2014-08-11", "choc11")));
- choc11Builder.withValue(Lists.newArrayList(children));
+ choc11Builder.withValue(Arrays.asList(children));
// choc11Builder.addChild(lf13Node());
// choc11Builder.addChild(augmentChoc11_c11A_lf1511AndLf1512Children());
// choc11Builder.addChild(augmentChoc11_c11_lf1521Children());
private static DataContainerChild<? extends PathArgument, ?> augmentC11AWithLf15_21Node() {
return Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(QName.create("ns:complex:json", "2014-08-11", "lf15_21"))))
+ new AugmentationIdentifier(Collections.singleton(QName.create("ns:complex:json", "2014-08-11", "lf15_21"))))
.withChild(lf15_21Node()).build();
}
private static DataContainerChild<? extends PathArgument, ?> augmentC11AWithLf15_11AndLf15_12Node() {
return Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(Sets.newHashSet(
+ .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(
QName.create("ns:complex:json", "2014-08-11", "lf15_11"),
QName.create("ns:complex:json", "2014-08-11", "lf15_12"))))
.withChild(lf15_11Node())
private static LeafNode<Object> lf15_11Node() {
return Builders.leafBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create("ns:complex:json", "2014-08-11", "lf15_11")))
- .withValue(Sets.newHashSet("one", "two")).build();
+ .withValue(ImmutableSet.of("one", "two")).build();
}
private static DataContainerChild<? extends PathArgument, ?> lf12_1Node() {
DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> augmentBuilder = Builders
.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(
+ new AugmentationIdentifier(ImmutableSet.of(
QName.create("ns:complex:json", "2014-08-11", "lf12_1"),
QName.create("ns:complex:json", "2014-08-11", "lf12_2"))));
augmentBuilder.withChild(Builders.leafBuilder()
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import javax.xml.namespace.NamespaceContext;
import org.opendaylight.yangtools.yang.data.impl.codec.DataStringCodec;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
private final DataStringCodec<T> codec;
protected AbstractXmlCodec(final DataStringCodec<T> codec) {
- this.codec = Preconditions.checkNotNull(codec);
+ this.codec = requireNonNull(codec);
}
@Override
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import java.net.URI;
import java.util.Map.Entry;
import javax.xml.namespace.NamespaceContext;
private final QNameModule parentModule;
IdentityrefXmlCodec(final SchemaContext context, final QNameModule parentModule) {
- this.schemaContext = Preconditions.checkNotNull(context);
- this.parentModule = Preconditions.checkNotNull(parentModule);
+ this.schemaContext = requireNonNull(context);
+ this.parentModule = requireNonNull(parentModule);
}
@Override
final String prefixedNS = ctx.getNamespaceURI(prefix);
final Module module = schemaContext.findModuleByNamespaceAndRevision(URI.create(prefixedNS), null);
- Preconditions.checkArgument(module != null, "Could not find module for namespace %s", prefixedNS);
+ checkArgument(module != null, "Could not find module for namespace %s", prefixedNS);
return module.getQNameModule();
});
}
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import java.net.URI;
int ret = 0;
for (char c : str.toCharArray()) {
int idx = LOOKUP.indexOf(c);
- Preconditions.checkArgument(idx != -1, "Invalid string %s", str);
+ checkArgument(idx != -1, "Invalid string %s", str);
ret = (ret << SHIFT) + idx;
}
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
import java.net.URI;
import java.util.Map.Entry;
import javax.xml.stream.XMLStreamException;
private final SchemaContext schemaContext;
SchemaAwareXMLStreamWriterUtils(final SchemaContext schemaContext) {
- this.schemaContext = Preconditions.checkNotNull(schemaContext);
+ this.schemaContext = requireNonNull(schemaContext);
}
@Override
TypeDefinition<?> getBaseTypeForLeafRef(final SchemaNode schemaNode, final LeafrefTypeDefinition type) {
final TypeDefinition<?> ret = SchemaContextUtil.getBaseTypeForLeafRef(type, schemaContext, schemaNode);
- return Verify.verifyNotNull(ret, "Unable to find base type for leafref node '%s'.", schemaNode.getPath());
+ return verifyNotNull(ret, "Unable to find base type for leafref node '%s'.", schemaNode.getPath());
}
@Override
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Iterator;
import java.util.List;
SingleType(final Class<T> dataClass, final List<XmlCodec<?>> codecs) {
super(codecs);
- this.dataClass = Preconditions.checkNotNull(dataClass);
+ this.dataClass = requireNonNull(dataClass);
}
@Override
static UnionXmlCodec<?> create(final UnionTypeDefinition type, final List<XmlCodec<?>> codecs) {
final Iterator<XmlCodec<?>> it = codecs.iterator();
- Verify.verify(it.hasNext(), "Union %s has no subtypes", type);
+ verify(it.hasNext(), "Union %s has no subtypes", type);
Class<?> dataClass = it.next().getDataType();
while (it.hasNext()) {
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Strings;
import java.io.IOException;
import java.io.StringWriter;
final XMLStreamWriter writer;
XMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer) {
- this.writer = Preconditions.checkNotNull(writer);
+ this.writer = requireNonNull(writer);
this.prefixes = new RandomPrefix(writer.getNamespaceContext());
}
void anyxmlNode(final QName qname, final Object value) throws IOException {
if (value != null) {
- Preconditions.checkArgument(value instanceof DOMSource, "AnyXML value must be DOMSource, not %s", value);
+ checkArgument(value instanceof DOMSource, "AnyXML value must be DOMSource, not %s", value);
final DOMSource domSource = (DOMSource) value;
- Preconditions.checkNotNull(domSource.getNode());
- Preconditions.checkArgument(domSource.getNode().getNodeName().equals(qname.getLocalName()));
- Preconditions.checkArgument(domSource.getNode().getNamespaceURI().equals(qname.getNamespace().toString()));
+ requireNonNull(domSource.getNode());
+ checkArgument(domSource.getNode().getNodeName().equals(qname.getLocalName()));
+ checkArgument(domSource.getNode().getNamespaceURI().equals(qname.getNamespace().toString()));
try {
// TODO can the transformer be a constant ? is it thread safe ?
final Transformer transformer = TRANSFORMER_FACTORY.newTransformer();
package org.opendaylight.yangtools.yang.data.codec.xml;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import java.util.Map.Entry;
import javax.annotation.Nonnull;
import javax.xml.stream.XMLStreamException;
return;
}
- Preconditions.checkArgument(schemaNode instanceof TypedSchemaNode,
+ checkArgument(schemaNode instanceof TypedSchemaNode,
"Unable to write value for node %s, only nodes of type: leaf and leaf-list can be written at this point",
schemaNode.getQName());
package org.opendaylight.yangtools.yang.data.codec.xml;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.xml.XmlEscapers;
import java.io.Closeable;
private XmlParserStream(final NormalizedNodeStreamWriter writer, final XmlCodecFactory codecs,
final DataSchemaNode parentNode, final boolean strictParsing) {
- this.writer = Preconditions.checkNotNull(writer);
- this.codecs = Preconditions.checkNotNull(codecs);
+ this.writer = requireNonNull(writer);
+ this.codecs = requireNonNull(codecs);
this.parentNode = parentNode;
this.strictParsing = strictParsing;
}
if (parentNode instanceof RpcDefinition) {
return new XmlParserStream(writer, codecs, new RpcAsContainer((RpcDefinition) parentNode), strictParsing);
}
- Preconditions.checkArgument(parentNode instanceof DataSchemaNode, "Instance of DataSchemaNode class awaited.");
+ checkArgument(parentNode instanceof DataSchemaNode, "Instance of DataSchemaNode class awaited.");
return new XmlParserStream(writer, codecs, (DataSchemaNode) parentNode, strictParsing);
}
}
private static Map<QName, String> getElementAttributes(final XMLStreamReader in) {
- Preconditions.checkState(in.isStartElement(), "Attributes can be extracted only from START_ELEMENT.");
+ checkState(in.isStartElement(), "Attributes can be extracted only from START_ELEMENT.");
final Map<QName, String> attributes = new LinkedHashMap<>();
for (int attrIndex = 0; attrIndex < in.getAttributeCount(); attrIndex++) {
new URI(xmlElementNamespace));
if (childDataSchemaNodes.isEmpty()) {
- Preconditions.checkState(!strictParsing,
- "Schema for node with name %s and namespace %s doesn't exist.", xmlElementName,
- xmlElementNamespace);
+ checkState(!strictParsing, "Schema for node with name %s and namespace %s doesn't exist.",
+ xmlElementName, xmlElementNamespace);
skipUnknownNode(in);
continue;
}
private void setValue(final AbstractNodeDataWithSchema parent, final String value, final NamespaceContext nsContext)
throws ParserConfigurationException, SAXException, IOException {
- Preconditions.checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type",
+ checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type",
parent.getSchema().getQName());
final SimpleNodeDataWithSchema parentSimpleNode = (SimpleNodeDataWithSchema) parent;
- Preconditions.checkArgument(parentSimpleNode.getValue() == null, "Node '%s' has already set its value to '%s'",
+ checkArgument(parentSimpleNode.getValue() == null, "Node '%s' has already set its value to '%s'",
parentSimpleNode.getSchema().getQName(), parentSimpleNode.getValue());
parentSimpleNode.setValue(translateValueByType(value, parentSimpleNode.getSchema(), nsContext));
return new DOMSource(doc.getDocumentElement());
}
- Preconditions.checkArgument(node instanceof TypedSchemaNode);
+ checkArgument(node instanceof TypedSchemaNode);
return codecs.codecFor((TypedSchemaNode) node).parseValue(namespaceCtx, value);
}
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import java.net.URI;
import java.util.ArrayDeque;
import java.util.Deque;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-final class XmlStringInstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec
+final class XmlStringInstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec
implements XmlCodec<YangInstanceIdentifier> {
private static final ThreadLocal<Deque<NamespaceContext>> TL_CONTEXT = new ThreadLocal<>();
private final SchemaContext context;
XmlStringInstanceIdentifierCodec(final SchemaContext context, final XmlCodecFactory xmlCodecFactory) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
this.dataContextTree = DataSchemaContextTree.from(context);
- this.codecFactory = Preconditions.checkNotNull(xmlCodecFactory);
+ this.codecFactory = requireNonNull(xmlCodecFactory);
}
@Override
@Override
protected Object deserializeKeyValue(final DataSchemaNode schemaNode, final String value) {
- Preconditions.checkNotNull(schemaNode, "schemaNode cannot be null");
- Preconditions.checkArgument(schemaNode instanceof LeafSchemaNode, "schemaNode must be of type LeafSchemaNode");
+ requireNonNull(schemaNode, "schemaNode cannot be null");
+ checkArgument(schemaNode instanceof LeafSchemaNode, "schemaNode must be of type LeafSchemaNode");
final XmlCodec<?> objectXmlCodec = codecFactory.codecFor((LeafSchemaNode) schemaNode);
return objectXmlCodec.parseValue(getNamespaceContext(), value);
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import com.google.common.base.Optional;
import java.io.InputStream;
import java.net.URI;
+import java.util.Optional;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import org.junit.Before;
Optional<DataContainerChild<? extends PathArgument, ?>> myLeaf = rootContainer.getChild(new NodeIdentifier(
QName.create(fooModuleQName, "my-leaf")));
- assertTrue(myLeaf.orNull() instanceof LeafNode);
+ assertTrue(myLeaf.orElse(null) instanceof LeafNode);
assertEquals(expectedValue, myLeaf.get().getValue());
}
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.io.BaseEncoding;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.net.URI;
+import java.util.Optional;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
final ContainerNode docNode = createDocNode();
Optional<DataContainerChild<? extends PathArgument, ?>> root = docNode.getChild(new NodeIdentifier(rootQName));
- assertTrue(root.orNull() instanceof ContainerNode);
+ assertTrue(root.orElse(null) instanceof ContainerNode);
- Optional<DataContainerChild<? extends PathArgument, ?>> child = ((ContainerNode) root.orNull())
+ Optional<DataContainerChild<? extends PathArgument, ?>> child = ((ContainerNode) root.orElse(null))
.getChild(new NodeIdentifier(ipAddressQName));
- assertTrue(child.orNull() instanceof LeafNode);
+ assertTrue(child.orElse(null) instanceof LeafNode);
LeafNode<?> ipAdress = (LeafNode<?>) child.get();
Object value = ipAdress.getValue();
private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
final InputStream resourceAsStream = Bug5446Test.class.getResourceAsStream(xmlPath);
- final Document currentConfigElement = readXmlToDocument(resourceAsStream);
- Preconditions.checkNotNull(currentConfigElement);
- return currentConfigElement;
+ return requireNonNull(readXmlToDocument(resourceAsStream));
}
private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
-import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
final NormalizedNodeStreamWriter streamWriter = XMLStreamNormalizedNodeStreamWriter.create(
xmlStreamWriter, schemaContext);
- final InputStream resourceAsStream = Bug8745Test.class.getResourceAsStream(
- "/bug8745/foo.xml");
- final XMLInputFactory inputFactory = XMLInputFactory.newInstance();
+ final InputStream resourceAsStream = Bug8745Test.class.getResourceAsStream("/bug8745/foo.xml");
// final XMLStreamReader reader = inputFactory.createXMLStreamReader(resourceAsStream);
final XMLStreamReader reader = new DOMSourceXMLStreamReader(domSource);
private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
final InputStream resourceAsStream = NormalizedNodesToXmlTest.class.getResourceAsStream(xmlPath);
- final Document currentConfigElement = readXmlToDocument(resourceAsStream);
- Preconditions.checkNotNull(currentConfigElement);
- return currentConfigElement;
+ return requireNonNull(readXmlToDocument(resourceAsStream));
}
private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
+import static java.util.Objects.requireNonNull;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
-import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
// deserialization
final Document doc = loadDocument("/dom-reader-test/foo.xml");
final DOMSource inputXml = new DOMSource(doc.getDocumentElement());
- XMLInputFactory inputFactory = XMLInputFactory.newFactory();
XMLStreamReader domXMLReader = new DOMSourceXMLStreamReader(inputXml);
final NormalizedNodeResult result = new NormalizedNodeResult();
private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
final InputStream resourceAsStream = NormalizedNodesToXmlTest.class.getResourceAsStream(xmlPath);
- final Document currentConfigElement = readXmlToDocument(resourceAsStream);
- Preconditions.checkNotNull(currentConfigElement);
- return currentConfigElement;
+ return requireNonNull(readXmlToDocument(resourceAsStream));
}
private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
package org.opendaylight.yangtools.yang.data.codec.xml;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.augmentationBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.choiceBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.containerBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.io.InputStream;
private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
final InputStream resourceAsStream = NormalizedNodeXmlTranslationTest.class.getResourceAsStream(xmlPath);
-
- final Document currentConfigElement = readXmlToDocument(resourceAsStream);
- Preconditions.checkNotNull(currentConfigElement);
- return currentConfigElement;
+ return requireNonNull(readXmlToDocument(resourceAsStream));
}
private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
for (Module module : context.getModules()) {
if (module.getName().equals(moduleName)) {
DataSchemaNode found = findChildNode(module.getChildNodes(), childNodeName);
- Preconditions.checkState(found != null, "Unable to find %s", childNodeName);
+ checkState(found != null, "Unable to find %s", childNodeName);
return found;
}
}
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.xml.stream.XMLOutputFactory;
.build();
AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(myDoublyKeyedList)))
+ new AugmentationIdentifier(Collections.singleton(myDoublyKeyedList)))
.withChild(myDoublyKeyedListNode).build();
ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
.withChild(myDoublyKeyedListAugNode).build();
AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(myContainer3)))
+ new AugmentationIdentifier(Collections.singleton(myContainer3)))
.withChild(myContainer3Node).build();
ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
final InputStream resourceAsStream = NormalizedNodesToXmlTest.class.getResourceAsStream(xmlPath);
- final Document currentConfigElement = readXmlToDocument(resourceAsStream);
- Preconditions.checkNotNull(currentConfigElement);
- return currentConfigElement;
+ return requireNonNull(readXmlToDocument(resourceAsStream));
}
private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
.build();
AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(myDoublyKeyedList)))
+ new AugmentationIdentifier(Collections.singleton(myDoublyKeyedList)))
.withChild(myDoublyKeyedListNode).build();
ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
.withChild(myDoublyKeyedListAugNode).build();
AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(myContainer3)))
+ new AugmentationIdentifier(Collections.singleton(myContainer3)))
.withChild(myContainer3Node).build();
ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
final InputStream resourceAsStream = SchemalessXMLStreamNormalizedNodeStreamWriterTest.class
.getResourceAsStream(xmlPath);
- final Document currentConfigElement = readXmlToDocument(resourceAsStream);
- Preconditions.checkNotNull(currentConfigElement);
- return currentConfigElement;
+ return requireNonNull(readXmlToDocument(resourceAsStream));
}
private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
-import com.google.common.collect.Maps;
import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.AbstractMap;
import java.util.Date;
+import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.stream.XMLOutputFactory;
QName name = getAttrQName("namespace", "2012-12-12", "attr", Optional.of("prefix"));
final Map.Entry<QName, String> attributeEntry = new AbstractMap.SimpleEntry<>(name, "value");
- name = getAttrQName("namespace2", "2012-12-12", "attr", Optional.absent());
+ name = getAttrQName("namespace2", "2012-12-12", "attr", Optional.empty());
final Map.Entry<QName, String> attributeEntryNoPrefix = new AbstractMap.SimpleEntry<>(name, "value");
final RandomPrefix randomPrefix = new RandomPrefix(null);
}
private static Map<String, String> mapPrefixed(final Iterable<Map.Entry<URI, String>> prefixes) {
- final Map<String, String> mappedPrefixes = Maps.newHashMap();
+ final Map<String, String> mappedPrefixes = new HashMap<>();
for (final Map.Entry<URI, String> prefix : prefixes) {
mappedPrefixes.put(prefix.getKey().toString(), prefix.getValue());
}
import static org.junit.Assert.fail;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Sets;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.xml.parsers.ParserConfigurationException;
.build();
AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(myDoublyKeyedList)))
+ new AugmentationIdentifier(Collections.singleton(myDoublyKeyedList)))
.withChild(myDoublyKeyedListNode).build();
ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
.withChild(myDoublyKeyedListAugNode).build();
AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(myContainer3)))
+ new AugmentationIdentifier(Collections.singleton(myContainer3)))
.withChild(myContainer3Node).build();
ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
import java.io.InputStream;
import java.net.URI;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
Optional<DataContainerChild<? extends PathArgument, ?>> child = yangModeledAnyXmlNode
.getChild(new NodeIdentifier(myContainer1));
- assertTrue(child.orNull() instanceof ContainerNode);
+ assertTrue(child.orElse(null) instanceof ContainerNode);
ContainerNode myContainerNode1 = (ContainerNode) child.get();
Optional<DataContainerChild<? extends PathArgument, ?>> child2 = myContainerNode1.getChild(new NodeIdentifier(
myLeaf1));
- assertTrue(child2.orNull() instanceof LeafNode);
+ assertTrue(child2.orElse(null) instanceof LeafNode);
LeafNode<?> leafNode1 = (LeafNode<?>) child2.get();
Object leafNode1Value = leafNode1.getValue();
Optional<DataContainerChild<? extends PathArgument, ?>> child2 = yangModeledAnyXmlNode
.getChild(new NodeIdentifier(innerContainer));
- assertTrue(child2.orNull() instanceof ContainerNode);
+ assertTrue(child2.orElse(null) instanceof ContainerNode);
ContainerNode innerContainerNode = (ContainerNode) child2.get();
Optional<DataContainerChild<? extends PathArgument, ?>> child3 = innerContainerNode
.getChild(new NodeIdentifier(myLeaf2));
- assertTrue(child3.orNull() instanceof LeafNode);
+ assertTrue(child3.orElse(null) instanceof LeafNode);
LeafNode<?> leafNode2 = (LeafNode<?>) child3.get();
Object leafNode2Value = leafNode2.getValue();
Optional<DataContainerChild<? extends PathArgument, ?>> child4 = yangModeledAnyXmlNode
.getChild(new NodeIdentifier(myLeaf3));
- assertTrue(child4.orNull() instanceof LeafNode);
+ assertTrue(child4.orElse(null) instanceof LeafNode);
LeafNode<?> leafNode3 = (LeafNode<?>) child4.get();
Object leafNode3Value = leafNode3.getValue();
package org.opendaylight.yangtools.yang.data.codec.xml;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.net.URI;
+import java.util.Optional;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamReader;
Optional<DataContainerChild<? extends PathArgument, ?>> bazContainerChild = bazContainer.getChild(
new NodeIdentifier(myAnyXMLDataBaz));
- assertTrue(bazContainerChild.orNull() instanceof YangModeledAnyXmlNode);
+ assertTrue(bazContainerChild.orElse(null) instanceof YangModeledAnyXmlNode);
YangModeledAnyXmlNode yangModeledAnyXmlNode = (YangModeledAnyXmlNode) bazContainerChild.get();
DataSchemaNode schemaOfAnyXmlData = yangModeledAnyXmlNode.getSchemaOfAnyXmlData();
private static Document loadDocument(final String xmlPath) throws IOException, SAXException {
final InputStream resourceAsStream = YangModeledAnyXMLSerializationTest.class.getResourceAsStream(xmlPath);
- final Document currentConfigElement = readXmlToDocument(resourceAsStream);
- Preconditions.checkNotNull(currentConfigElement);
- return currentConfigElement;
+ return requireNonNull(readXmlToDocument(resourceAsStream));
}
private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException {
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
+import static com.google.common.base.Preconditions.checkArgument;
import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT16_QNAME;
import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT32_QNAME;
import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT64_QNAME;
import com.google.common.annotations.Beta;
import com.google.common.base.CharMatcher;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Range;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.regex.Pattern;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
}
private static int provideBase(final String integer) {
- Preconditions.checkArgument(integer != null, "String representing integer number cannot be NULL");
+ checkArgument(integer != null, "String representing integer number cannot be NULL");
if (integer.length() == 1 && integer.charAt(0) == '0') {
return 10;
}
private static String normalizeHexadecimal(final String hexInt) {
- Preconditions.checkArgument(hexInt != null,
- "String representing integer number in Hexadecimal format cannot be NULL!");
-
+ checkArgument(hexInt != null, "String representing integer number in Hexadecimal format cannot be NULL!");
return X_MATCHER.removeFrom(hexInt);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import com.google.common.collect.TreeRangeSet;
import com.google.common.io.BaseEncoding;
+import java.util.Optional;
import javax.xml.bind.DatatypeConverter;
import org.opendaylight.yangtools.yang.data.api.codec.BinaryCodec;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-
/**
* Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
*/
@Override
void validate(final byte[] value) {
- Preconditions.checkArgument(ranges.contains(value.length),
- "Value length %s does not match constraints %s", value.length, ranges);
+ checkArgument(ranges.contains(value.length), "Value length %s does not match constraints %s", value.length,
+ ranges);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Joiner;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.data.api.codec.BitsCodec;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
@SuppressWarnings("unchecked")
private BitsStringCodec(final Optional<BitsTypeDefinition> typeDef) {
- super(typeDef, (Class<Set<String>>) ((Class<?>) Set.class));
+ super(typeDef, (Class<Set<String>>) (Class<?>) Set.class);
if (typeDef.isPresent()) {
validBits = ImmutableSet.copyOf(Collections2.transform(typeDef.get().getBits(), Bit::getName));
} else {
// an invalid bit.
if (sorted.size() != strings.size()) {
for (final String bit : strings) {
- Preconditions.checkArgument(validBits.contains(bit),
- "Invalid value '%s' for bits type. Allowed values are: %s", bit, validBits);
+ checkArgument(validBits.contains(bit), "Invalid value '%s' for bits type. Allowed values are: %s", bit,
+ validBits);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.BooleanCodec;
import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
if (stringRepresentation == null) {
return null;
}
- Preconditions.checkArgument("true".equalsIgnoreCase(stringRepresentation)
- || "false".equalsIgnoreCase(stringRepresentation),
+ checkArgument("true".equalsIgnoreCase(stringRepresentation) || "false".equalsIgnoreCase(stringRepresentation),
"Invalid value '%s' for boolean type. Allowed values are true and false", stringRepresentation);
return Boolean.valueOf(stringRepresentation);
}
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Strings;
import java.util.regex.Pattern;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
}
public void validate(final String str) {
- Preconditions.checkArgument(pattern.matcher(str).matches(), errorMessage, str);
+ checkArgument(pattern.matcher(str).matches(), errorMessage, str);
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.math.BigDecimal;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.DecimalCodec;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
@Override
public BigDecimal deserialize(final String stringRepresentation) {
- Preconditions.checkArgument(stringRepresentation != null, "Input cannot be null");
+ checkArgument(stringRepresentation != null, "Input cannot be null");
// FIXME: run value validation
return new BigDecimal(stringRepresentation);
}
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Strings;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.EmptyCodec;
import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
static final EmptyStringCodec INSTANCE = new EmptyStringCodec();
private EmptyStringCodec() {
- super(Optional.absent(), Void.class);
+ super(Optional.empty(), Void.class);
}
@Override
@Override
public Void deserialize(final String stringRepresentation) {
- Preconditions.checkArgument(Strings.isNullOrEmpty(stringRepresentation), "The value must be empty");
+ checkArgument(Strings.isNullOrEmpty(stringRepresentation), "The value must be empty");
return null;
}
}
\ No newline at end of file
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.EnumCodec;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
// Lookup the serialized string in the values. Returned string is the interned instance, which we want
// to use as the result.
final String result = values.get(stringRepresentation);
- Preconditions.checkArgument(result != null, "Invalid value '%s' for enum type. Allowed values are: %s",
- stringRepresentation, values.keySet());
+ checkArgument(result != null, "Invalid value '%s' for enum type. Allowed values are: %s", stringRepresentation,
+ values.keySet());
return result;
}
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.Int16Codec;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
final class Int16StringCodec extends AbstractIntegerStringCodec<Short, IntegerTypeDefinition>
implements Int16Codec<String> {
Int16StringCodec(final Optional<IntegerTypeDefinition> typeDef) {
- super(typeDef, extractRange(typeDef.orNull()), Short.class);
+ super(typeDef, extractRange(typeDef.orElse(null)), Short.class);
}
@Override
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.Int32Codec;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
final class Int32StringCodec extends AbstractIntegerStringCodec<Integer, IntegerTypeDefinition>
implements Int32Codec<String> {
Int32StringCodec(final Optional<IntegerTypeDefinition> typeDef) {
- super(typeDef, extractRange(typeDef.orNull()), Integer.class);
+ super(typeDef, extractRange(typeDef.orElse(null)), Integer.class);
}
@Override
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.Int64Codec;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
implements Int64Codec<String> {
Int64StringCodec(final Optional<IntegerTypeDefinition> typeDef) {
- super(typeDef, extractRange(typeDef.orNull()), Long.class);
+ super(typeDef, extractRange(typeDef.orElse(null)), Long.class);
}
@Override
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.Int8Codec;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
implements Int8Codec<String> {
Int8StringCodec(final Optional<IntegerTypeDefinition> typeDef) {
- super(typeDef, extractRange(typeDef.orNull()), Byte.class);
+ super(typeDef, extractRange(typeDef.orElse(null)), Byte.class);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import java.io.IOException;
import java.util.ArrayDeque;
private SchemaTracker(final SchemaContext context, final SchemaPath path) {
final Collection<SchemaNode> schemaNodes = SchemaUtils.findParentSchemaNodesOnPath(context, path);
- Preconditions.checkArgument(!schemaNodes.isEmpty(), "Unable to find schema node for supplied schema path: %s",
- path);
+ checkArgument(!schemaNodes.isEmpty(), "Unable to find schema node for supplied schema path: %s", path);
if (schemaNodes.size() > 1) {
LOG.warn("More possible schema nodes {} for supplied schema path {}", schemaNodes, path);
}
final Optional<SchemaNode> current = schemaNodes.stream().filter(node -> node instanceof DataNodeContainer)
.findFirst();
- Preconditions.checkArgument(current.isPresent(),
+ checkArgument(current.isPresent(),
"Schema path must point to container or list or an rpc input/output. Supplied path %s pointed to: %s",
path, current);
root = (DataNodeContainer) current.get();
throw new IllegalStateException("Unsupported schema type " + parent.getClass() + " on stack.");
}
- Preconditions.checkArgument(schema != null, "Could not find schema for node %s in %s", qname, parent);
+ checkArgument(schema != null, "Could not find schema for node %s in %s", qname, parent);
return schema;
}
public void startList(final PathArgument name) {
final SchemaNode schema = getSchema(name);
- Preconditions.checkArgument(schema instanceof ListSchemaNode, "Node %s is not a list", schema.getPath());
+ checkArgument(schema instanceof ListSchemaNode, "Node %s is not a list", schema.getPath());
schemaStack.push(schema);
}
public void startListItem(final PathArgument name) throws IOException {
final Object schema = getParent();
- Preconditions.checkArgument(schema instanceof ListSchemaNode, "List item is not appropriate");
+ checkArgument(schema instanceof ListSchemaNode, "List item is not appropriate");
schemaStack.push(schema);
}
public LeafSchemaNode leafNode(final NodeIdentifier name) throws IOException {
final SchemaNode schema = getSchema(name);
- Preconditions.checkArgument(schema instanceof LeafSchemaNode, "Node %s is not a leaf", schema.getPath());
+ checkArgument(schema instanceof LeafSchemaNode, "Node %s is not a leaf", schema.getPath());
return (LeafSchemaNode) schema;
}
public LeafListSchemaNode startLeafSet(final NodeIdentifier name) {
final SchemaNode schema = getSchema(name);
- Preconditions.checkArgument(schema instanceof LeafListSchemaNode, "Node %s is not a leaf-list",
- schema.getPath());
+ checkArgument(schema instanceof LeafListSchemaNode, "Node %s is not a leaf-list", schema.getPath());
schemaStack.push(schema);
return (LeafListSchemaNode)schema;
}
public LeafListSchemaNode leafSetEntryNode() {
final Object parent = getParent();
- Preconditions.checkArgument(parent instanceof LeafListSchemaNode, "Not currently in a leaf-list");
+ checkArgument(parent instanceof LeafListSchemaNode, "Not currently in a leaf-list");
return (LeafListSchemaNode) parent;
}
}
final SchemaNode child = SchemaUtils.findDataChildSchemaByQName((SchemaNode) parent, qname);
- Preconditions.checkArgument(child instanceof LeafListSchemaNode,
+ checkArgument(child instanceof LeafListSchemaNode,
"Node %s is neither a leaf-list nor currently in a leaf-list", child.getPath());
return (LeafListSchemaNode) child;
}
LOG.debug("Enter choice {}", name);
final SchemaNode schema = getSchema(name);
- Preconditions.checkArgument(schema instanceof ChoiceSchemaNode, "Node %s is not a choice", schema.getPath());
+ checkArgument(schema instanceof ChoiceSchemaNode, "Node %s is not a choice", schema.getPath());
schemaStack.push(schema);
return (ChoiceSchemaNode)schema;
}
boolean isAllowed = schema instanceof ContainerSchemaNode;
isAllowed |= schema instanceof NotificationDefinition;
- Preconditions.checkArgument(isAllowed, "Node %s is not a container nor a notification", schema.getPath());
+ checkArgument(isAllowed, "Node %s is not a container nor a notification", schema.getPath());
schemaStack.push(schema);
return schema;
LOG.debug("Enter yang modeled anyXml {}", name);
final SchemaNode schema = getSchema(name);
- Preconditions.checkArgument(schema instanceof YangModeledAnyXmlSchemaNode,
- "Node %s is not an yang modeled anyXml.", schema.getPath());
+ checkArgument(schema instanceof YangModeledAnyXmlSchemaNode, "Node %s is not an yang modeled anyXml.",
+ schema.getPath());
schemaStack.push(((YangModeledAnyXmlSchemaNode) schema).getSchemaOfAnyXmlData());
LOG.debug("Enter augmentation {}", identifier);
Object parent = getParent();
- Preconditions.checkArgument(parent instanceof AugmentationTarget, "Augmentation not allowed under %s", parent);
+ checkArgument(parent instanceof AugmentationTarget, "Augmentation not allowed under %s", parent);
if (parent instanceof ChoiceSchemaNode) {
final QName name = Iterables.get(identifier.getPossibleChildNames(), 0);
parent = findCaseByChild((ChoiceSchemaNode) parent, name);
}
- Preconditions.checkArgument(parent instanceof DataNodeContainer,
- "Augmentation allowed only in DataNodeContainer", parent);
+ checkArgument(parent instanceof DataNodeContainer, "Augmentation allowed only in DataNodeContainer", parent);
final AugmentationSchema schema = SchemaUtils.findSchemaForAugment((AugmentationTarget) parent,
identifier.getPossibleChildNames());
final HashSet<DataSchemaNode> realChildSchemas = new HashSet<>();
public AnyXmlSchemaNode anyxmlNode(final NodeIdentifier name) {
final SchemaNode schema = getSchema(name);
-
- Preconditions.checkArgument(schema instanceof AnyXmlSchemaNode, "Node %s is not anyxml", schema.getPath());
+ checkArgument(schema instanceof AnyXmlSchemaNode, "Node %s is not anyxml", schema.getPath());
return (AnyXmlSchemaNode)schema;
}
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import com.google.common.collect.TreeRangeSet;
import java.util.Collection;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.StringCodec;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
void validate(final String str) {
if (lengths != null) {
- Preconditions.checkArgument(lengths.contains(str.length()), "String '%s' does not match allowed lengths %s",
- lengths);
+ checkArgument(lengths.contains(str.length()), "String '%s' does not match allowed lengths %s", lengths);
}
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
+import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
private final T typeDefinition;
protected TypeDefinitionAwareCodec(final Optional<T> typeDefinition, final Class<J> outputClass) {
- Preconditions.checkArgument(outputClass != null, "Output class must be specified.");
- this.typeDefinition = typeDefinition.orNull();
- this.inputClass = outputClass;
+ this.typeDefinition = typeDefinition.orElse(null);
+ this.inputClass = requireNonNull(outputClass);
}
@Override
}
public Optional<T> getTypeDefinition() {
- return Optional.fromNullable(typeDefinition);
+ return Optional.ofNullable(typeDefinition);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.Uint16Codec;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
final class Uint16StringCodec extends AbstractIntegerStringCodec<Integer, UnsignedIntegerTypeDefinition> implements
Uint16Codec<String> {
Uint16StringCodec(final Optional<UnsignedIntegerTypeDefinition> typeDef) {
- super(typeDef, extractRange(typeDef.orNull()), Integer.class);
+ super(typeDef, extractRange(typeDef.orElse(null)), Integer.class);
}
@Override
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.Uint32Codec;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
Uint32Codec<String> {
Uint32StringCodec(final Optional<UnsignedIntegerTypeDefinition> typeDef) {
- super(typeDef, extractRange(typeDef.orNull()), Long.class);
+ super(typeDef, extractRange(typeDef.orElse(null)), Long.class);
}
@Override
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.Uint64Codec;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
Uint64Codec<String> {
Uint64StringCodec(final Optional<UnsignedIntegerTypeDefinition> typeDef) {
- super(typeDef, extractRange(typeDef.orNull()), BigInteger.class);
+ super(typeDef, extractRange(typeDef.orElse(null)), BigInteger.class);
}
@Override
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.Uint8Codec;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
Uint8Codec<String> {
Uint8StringCodec(final Optional<UnsignedIntegerTypeDefinition> typeDef) {
- super(typeDef, extractRange(typeDef.orNull()), Short.class);
+ super(typeDef, extractRange(typeDef.orElse(null)), Short.class);
}
@Override
package org.opendaylight.yangtools.yang.data.impl.codec;
-import com.google.common.base.Optional;
import com.google.common.io.BaseEncoding;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.codec.UnionCodec;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
}
static TypeDefinitionAwareCodec<?, UnionTypeDefinition> from(final UnionTypeDefinition normalizedType) {
- return new UnionStringCodec(Optional.fromNullable(normalizedType));
+ return new UnionStringCodec(Optional.ofNullable(normalizedType));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.leafref;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkNotNull;
+
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
currentLeafRefContextBuilder.setReferencing(true);
final LeafRefPathParserImpl leafRefPathParser = new LeafRefPathParserImpl(schemaContext,
- Preconditions.checkNotNull(getBaseTypeModule(leafrefType),
- "Unable to find base module for leafref %s", node),
+ checkNotNull(getBaseTypeModule(leafrefType), "Unable to find base module for leafref %s", node),
node);
final LeafRefPath leafRefPath = leafRefPathParser.parseLeafRefPathSourceToSchemaPath(
*/
package org.opendaylight.yangtools.yang.data.impl.leafref;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import java.util.Arrays;
* @return A new child path
*/
public LeafRefPath createChild(final LeafRefPath relative) {
- Preconditions.checkArgument(!relative.isAbsolute(), "Child creation requires relative path");
+ checkArgument(!relative.isAbsolute(), "Child creation requires relative path");
LeafRefPath parent = this;
for (QNameWithPredicate qname : relative.getPathFromRoot()) {
*/
package org.opendaylight.yangtools.yang.data.impl.leafref;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.collect.Lists;
import java.net.URI;
import java.util.ArrayList;
final String prefix = ctx.getText();
if (!module.getPrefix().equals(prefix)) {
final Optional<QNameModule> qnameModuleOpt = getQNameModuleForImportPrefix(prefix);
- Preconditions.checkArgument(qnameModuleOpt.isPresent(), "No module import for prefix: %s in module: %s",
- prefix, module.getName());
+ checkArgument(qnameModuleOpt.isPresent(), "No module import for prefix: %s in module: %s", prefix,
+ module.getName());
currentQnameModule = qnameModuleOpt.get();
} else {
currentQnameModule = module.getQNameModule();
*/
package org.opendaylight.yangtools.yang.data.impl.leafref;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
return currentNode;
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static Iterable<QNameWithPredicate> nextLevel(final Iterable<QNameWithPredicate> path) {
*/
package org.opendaylight.yangtools.yang.data.impl.leafref;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.Serializable;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
private final LeafRefPath pathKeyExpression;
QNamePredicateImpl(final QName identifier, final LeafRefPath pathKeyExpression) {
- this.identifier = Preconditions.checkNotNull(identifier, "QNamePredicate: identifier should not be null");
- this.pathKeyExpression = Preconditions.checkNotNull(pathKeyExpression,
+ this.identifier = requireNonNull(identifier, "QNamePredicate: identifier should not be null");
+ this.pathKeyExpression = requireNonNull(pathKeyExpression,
"QNamePredicate: pathKeyExpression should not be null");
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
* @return serialized normalized node for provided instance Id
*/
public static NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id) {
- return fromInstanceId(ctx, id, Optional.absent(), Optional.absent());
+ return fromInstanceId(ctx, id, Optional.empty(), Optional.empty());
}
/**
*/
public static NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
final NormalizedNode<?, ?> deepestElement) {
- return fromInstanceId(ctx, id, Optional.of(deepestElement), Optional.absent());
+ return fromInstanceId(ctx, id, Optional.of(deepestElement), Optional.empty());
}
/**
*/
public static NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
final Optional<NormalizedNode<?, ?>> deepestElement, final Optional<Entry<QName, ModifyAction>> operation) {
- Preconditions.checkNotNull(ctx);
- Preconditions.checkNotNull(id);
final YangInstanceIdentifier.PathArgument topLevelElement = id.getPathArguments().get(0);
final DataSchemaNode dataChildByName = ctx.getDataChildByName(topLevelElement.getNodeType());
Preconditions.checkNotNull(dataChildByName,
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.yangtools.yang.common.QName;
builder.addChild(childOp.create(childId, lastChild, operation));
} else {
if (lastChild.isPresent()) {
- builder.withValue(Lists.newArrayList((Collection<?>) lastChild.get().getValue()));
+ builder.withValue(ImmutableList.copyOf((Collection<?>) lastChild.get().getValue()));
}
if (operation.isPresent()) {
- Preconditions.checkArgument(builder instanceof AttributesBuilder<?>);
+ checkArgument(builder instanceof AttributesBuilder<?>);
addModifyOpIfPresent(operation, (AttributesBuilder<?>) builder);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import java.util.Collections;
import java.util.List;
import java.util.Map.Entry;
+import java.util.Optional;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
if (deepestChild.isPresent()) {
final NormalizedNode<?, ?> child = deepestChild.get();
Preconditions.checkState(child instanceof AnyXmlNode);
-
final NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> anyXmlBuilder =
Builders.anyXmlBuilder().withNodeIdentifier(getIdentifier()).withValue(
((AnyXmlNode) child).getValue());
if (potential == null) {
potential = findChoice(Iterables.filter(parent.getChildNodes(), ChoiceSchemaNode.class), child);
}
- return Optional.fromNullable(potential);
+ return Optional.ofNullable(potential);
}
static InstanceIdToNodes<?> fromSchemaAndQNameChecked(final DataNodeContainer schema, final QName child) {
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
+import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@Override
protected NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> getBuilder(
final PathArgument node) {
- Preconditions.checkArgument(node instanceof NodeWithValue);
+ checkArgument(node instanceof NodeWithValue);
return Builders.leafSetEntryBuilder().withNodeIdentifier((NodeWithValue<?>) node)
.withValue(((NodeWithValue<?>) node).getValue());
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.HashSet;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
}
}
}
- return Optional.fromNullable(schema);
+ return Optional.ofNullable(schema);
}
/**
}
public static AugmentationSchema findSchemaForAugment(final ChoiceSchemaNode schema, final Set<QName> qnames) {
- Optional<AugmentationSchema> schemaForAugment = Optional.absent();
+ Optional<AugmentationSchema> schemaForAugment = Optional.empty();
for (final ChoiceCaseNode choiceCaseNode : schema.getCases()) {
schemaForAugment = findAugment(choiceCaseNode, qnames);
private static Optional<AugmentationSchema> findAugment(final AugmentationTarget schema, final Set<QName> qnames) {
for (final AugmentationSchema augment : schema.getAvailableAugmentations()) {
- final HashSet<QName> qNamesFromAugment = Sets.newHashSet(Collections2.transform(augment.getChildNodes(),
+ final Set<QName> qNamesFromAugment = ImmutableSet.copyOf(Collections2.transform(augment.getChildNodes(),
DataSchemaNode::getQName));
if (qNamesFromAugment.equals(qnames)) {
}
}
- return Optional.absent();
+ return Optional.empty();
}
/**
private static Map<QName, ChoiceSchemaNode> mapChildElementsFromChoices(final DataNodeContainer schema,
final Iterable<DataSchemaNode> childNodes) {
- final Map<QName, ChoiceSchemaNode> mappedChoices = Maps.newLinkedHashMap();
+ final Map<QName, ChoiceSchemaNode> mappedChoices = new LinkedHashMap<>();
for (final DataSchemaNode childSchema : childNodes) {
if (childSchema instanceof ChoiceSchemaNode) {
*/
public static Map<QName, AugmentationSchema> mapChildElementsFromAugments(final AugmentationTarget schema) {
- final Map<QName, AugmentationSchema> childNodesToAugmentation = Maps.newLinkedHashMap();
+ final Map<QName, AugmentationSchema> childNodesToAugmentation = new LinkedHashMap<>();
// Find QNames of augmented child nodes
- final Map<QName, AugmentationSchema> augments = Maps.newHashMap();
+ final Map<QName, AugmentationSchema> augments = new HashMap<>();
for (final AugmentationSchema augmentationSchema : schema.getAvailableAugmentations()) {
for (final DataSchemaNode dataSchemaNode : augmentationSchema.getChildNodes()) {
augments.put(dataSchemaNode.getQName(), augmentationSchema);
* @return set of QNames
*/
public static Set<QName> getChildNodesRecursive(final DataNodeContainer nodeContainer) {
- final Set<QName> allChildNodes = Sets.newHashSet();
+ final Set<QName> allChildNodes = new HashSet<>();
for (final DataSchemaNode childSchema : nodeContainer.getChildNodes()) {
if (childSchema instanceof ChoiceSchemaNode) {
if (!targetSchema.getAvailableAugmentations().contains(augmentSchema)) {
return Collections.emptySet();
}
-
- Set<DataSchemaNode> realChildNodes = Sets.newHashSet();
-
if (targetSchema instanceof DataNodeContainer) {
- realChildNodes = getRealSchemasForAugment((DataNodeContainer)targetSchema, augmentSchema);
- } else if (targetSchema instanceof ChoiceSchemaNode) {
+ return getRealSchemasForAugment((DataNodeContainer)targetSchema, augmentSchema);
+ }
+ final Set<DataSchemaNode> realChildNodes = new HashSet<>();
+ if (targetSchema instanceof ChoiceSchemaNode) {
for (final DataSchemaNode dataSchemaNode : augmentSchema.getChildNodes()) {
for (final ChoiceCaseNode choiceCaseNode : ((ChoiceSchemaNode) targetSchema).getCases()) {
if (getChildNodesRecursive(choiceCaseNode).contains(dataSchemaNode.getQName())) {
public static Set<DataSchemaNode> getRealSchemasForAugment(final DataNodeContainer targetSchema,
final AugmentationSchema augmentSchema) {
- final Set<DataSchemaNode> realChildNodes = Sets.newHashSet();
+ final Set<DataSchemaNode> realChildNodes = new HashSet<>();
for (final DataSchemaNode dataSchemaNode : augmentSchema.getChildNodes()) {
final DataSchemaNode realChild = targetSchema.getDataChildByName(dataSchemaNode.getQName());
realChildNodes.add(realChild);
}
}
- return Optional.absent();
+ return Optional.empty();
}
public static boolean belongsToCaseAugment(final ChoiceCaseNode caseNode,
final AugmentationIdentifier childToProcess) {
for (final AugmentationSchema augmentationSchema : caseNode.getAvailableAugmentations()) {
- final Set<QName> currentAugmentChildNodes = Sets.newHashSet();
+ final Set<QName> currentAugmentChildNodes = new HashSet<>();
for (final DataSchemaNode dataSchemaNode : augmentationSchema.getChildNodes()) {
currentAugmentChildNodes.add(dataSchemaNode.getQName());
}
if (node instanceof DataNodeContainer) {
child = ((DataNodeContainer) node).getDataChildByName(qname);
if (child == null && node instanceof SchemaContext) {
- child = tryFindRpc((SchemaContext) node, qname).orNull();
+ child = tryFindRpc((SchemaContext) node, qname).orElse(null);
}
if (child == null && node instanceof NotificationNodeContainer) {
- child = tryFindNotification((NotificationNodeContainer) node, qname).orNull();
+ child = tryFindNotification((NotificationNodeContainer) node, qname).orElse(null);
}
if (child == null && node instanceof ActionNodeContainer) {
- child = tryFindAction((ActionNodeContainer) node, qname).orNull();
+ child = tryFindAction((ActionNodeContainer) node, qname).orElse(null);
}
} else if (node instanceof ChoiceSchemaNode) {
child = ((ChoiceSchemaNode) node).getCaseNodeByName(qname);
public static SchemaNode findChildSchemaByQName(final SchemaNode node, final QName qname) {
SchemaNode child = findDataChildSchemaByQName(node, qname);
if (child == null && node instanceof DataNodeContainer) {
- child = tryFindGroupings((DataNodeContainer) node, qname).orNull();
+ child = tryFindGroupings((DataNodeContainer) node, qname).orElse(null);
}
return child;
childNodes.add(dataNode);
}
if (node instanceof DataNodeContainer) {
- final SchemaNode groupingNode = tryFindGroupings((DataNodeContainer) node, qname).orNull();
- if (groupingNode != null) {
- childNodes.add(groupingNode);
- }
+ tryFindGroupings((DataNodeContainer) node, qname).ifPresent(childNodes::add);
}
return childNodes.isEmpty() ? Collections.emptyList() : ImmutableList.copyOf(childNodes);
}
private static Optional<SchemaNode> tryFindGroupings(final DataNodeContainer dataNodeContainer, final QName qname) {
return Optional
- .fromNullable(Iterables.find(dataNodeContainer.getGroupings(), new SchemaNodePredicate(qname), null));
+ .ofNullable(Iterables.find(dataNodeContainer.getGroupings(), new SchemaNodePredicate(qname), null));
}
private static Optional<SchemaNode> tryFindRpc(final SchemaContext ctx, final QName qname) {
- return Optional.fromNullable(Iterables.find(ctx.getOperations(), new SchemaNodePredicate(qname), null));
+ return Optional.ofNullable(Iterables.find(ctx.getOperations(), new SchemaNodePredicate(qname), null));
}
private static Optional<SchemaNode> tryFindNotification(final NotificationNodeContainer notificationContanier,
final QName qname) {
- return Optional.fromNullable(
+ return Optional.ofNullable(
Iterables.find(notificationContanier.getNotifications(), new SchemaNodePredicate(qname), null));
}
private static Optional<SchemaNode> tryFindAction(final ActionNodeContainer actionContanier, final QName qname) {
- return Optional.fromNullable(Iterables.find(actionContanier.getActions(), new SchemaNodePredicate(qname),
- null));
+ return Optional.ofNullable(Iterables.find(actionContanier.getActions(), new SchemaNodePredicate(qname), null));
}
private static final class SchemaNodePredicate implements Predicate<SchemaNode> {
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
private DataNodeContainerValidator validator;
protected ImmutableChoiceNodeSchemaAwareBuilder(final ChoiceSchemaNode schema) {
- this.schema = Preconditions.checkNotNull(schema, "Schema was null");
+ this.schema = requireNonNull(schema, "Schema was null");
super.withNodeIdentifier(NodeIdentifier.create(schema.getQName()));
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import java.util.Map;
import java.util.Objects;
import org.opendaylight.yangtools.yang.common.QName;
ImmutableLeafSetEntryNode(final NodeWithValue nodeIdentifier, final T value,
final Map<QName, String> attributes) {
super(nodeIdentifier, value, attributes);
- Preconditions.checkArgument(Objects.deepEquals(nodeIdentifier.getValue(), value),
+ checkArgument(Objects.deepEquals(nodeIdentifier.getValue(), value),
"Node identifier contains different value: %s than value itself: %s", nodeIdentifier, value);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
private final LeafListSchemaNode schema;
private ImmutableLeafSetEntryNodeSchemaAwareBuilder(final LeafListSchemaNode schema) {
- this.schema = Preconditions.checkNotNull(schema);
+ this.schema = requireNonNull(schema);
}
public static <T> NormalizedNodeAttrBuilder<NodeWithValue, T, LeafSetEntryNode<T>> create(
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Optional;
import com.google.common.collect.Maps;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
@Override
public Optional<LeafSetEntryNode<T>> getChild(final NodeWithValue child) {
- return Optional.fromNullable(children.get(child));
+ return Optional.ofNullable(children.get(child));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collections;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
private final LeafListSchemaNode schema;
private ImmutableLeafSetNodeSchemaAwareBuilder(final LeafListSchemaNode schema) {
- this.schema = Preconditions.checkNotNull(schema);
+ this.schema = requireNonNull(schema);
super.withNodeIdentifier(new NodeIdentifier(schema.getQName()));
}
public ImmutableLeafSetNodeSchemaAwareBuilder(final LeafListSchemaNode schema, final ImmutableLeafSetNode<T> node) {
super(node);
- this.schema = Preconditions.checkNotNull(schema);
+ this.schema = requireNonNull(schema);
// FIXME: Preconditions.checkArgument(schema.getQName().equals(node.getIdentifier()));
super.withNodeIdentifier(new NodeIdentifier(schema.getQName()));
}
@Override
public ListNodeBuilder<T, LeafSetEntryNode<T>> withChild(final LeafSetEntryNode<T> child) {
- Preconditions.checkArgument(schema.getQName().equals(child.getNodeType()),
+ checkArgument(schema.getQName().equals(child.getNodeType()),
"Incompatible node type, should be: %s, is: %s", schema.getQName(), child.getNodeType());
// TODO check value type using TypeProvider ?
DataValidationException.checkLegalChild(schema.getQName().equals(child.getNodeType()), child.getIdentifier(),
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Optional;
import com.google.common.collect.Maps;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
@Override
public Optional<MapEntryNode> getChild(final NodeIdentifierWithPredicates child) {
- return Optional.fromNullable(children.get(child));
+ return Optional.ofNullable(children.get(child));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
import org.opendaylight.yangtools.yang.common.QName;
@Override
public Optional<LeafSetEntryNode<T>> getChild(final NodeWithValue child) {
- return Optional.fromNullable(children.get(child));
+ return Optional.ofNullable(children.get(child));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
+import java.util.Collections;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
private final LeafListSchemaNode schema;
private ImmutableOrderedLeafSetNodeSchemaAwareBuilder(final LeafListSchemaNode schema) {
- this.schema = Preconditions.checkNotNull(schema);
+ this.schema = requireNonNull(schema);
super.withNodeIdentifier(new NodeIdentifier(schema.getQName()));
}
public ImmutableOrderedLeafSetNodeSchemaAwareBuilder(final LeafListSchemaNode schema,
final ImmutableOrderedLeafSetNode<T> node) {
super(node);
- this.schema = Preconditions.checkNotNull(schema);
+ this.schema = requireNonNull(schema);
// FIXME: Preconditions.checkArgument(schema.getQName().equals(node.getIdentifier()));
super.withNodeIdentifier(new NodeIdentifier(schema.getQName()));
}
@Override
public ListNodeBuilder<T, LeafSetEntryNode<T>> withChild(final LeafSetEntryNode<T> child) {
- Preconditions.checkArgument(schema.getQName().equals(child.getNodeType()),
- "Incompatible node type, should be: %s, is: %s", schema.getQName(), child.getNodeType());
+ checkArgument(schema.getQName().equals(child.getNodeType()), "Incompatible node type, should be: %s, is: %s",
+ schema.getQName(), child.getNodeType());
// TODO check value type using TypeProvider ?
DataValidationException.checkLegalChild(schema.getQName().equals(child.getNodeType()), child.getIdentifier(),
- schema, Sets.newHashSet(schema.getQName()));
+ schema, Collections.singleton(schema.getQName()));
return super.withChild(child);
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
@Override
public Optional<MapEntryNode> getChild(final NodeIdentifierWithPredicates child) {
- return Optional.fromNullable(children.get(child));
+ return Optional.ofNullable(children.get(child));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.nodes;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.util.ImmutableOffsetMap;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@Override
public final Optional<DataContainerChild<? extends PathArgument, ?>> getChild(final PathArgument child) {
- return Optional.fromNullable(children.get(child));
+ return Optional.ofNullable(children.get(child));
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.UncheckedExecutionException;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
@Override
public final Optional<ModificationApplyOperation> getChild(final PathArgument identifier) {
try {
- return Optional.fromNullable(childCache.get(identifier));
+ return Optional.ofNullable(childCache.get(identifier));
} catch (ExecutionException | UncheckedExecutionException e) {
LOG.trace("Child {} not present in container schema {} children {}", identifier, this,
schema.getChildNodes(), e.getCause());
- return Optional.absent();
+ return Optional.empty();
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Collections2;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
private static Optional<NormalizedNode<?, ?>> getChild(
final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> container,
final PathArgument identifier) {
- return container == null ? Optional.absent() : container.getChild(identifier);
+ return container == null ? Optional.empty() : container.getChild(identifier);
}
static DataTreeCandidateNode deltaChild(
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateTip;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Collections;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
final TreeNode newMeta) {
this.newMeta = newMeta;
this.oldMeta = oldMeta;
- this.mod = Preconditions.checkNotNull(mod);
+ this.mod = requireNonNull(mod);
}
protected final ModifiedNode getMod() {
}
private static TreeNode childMeta(final TreeNode parent, final PathArgument id) {
- return parent == null ? null : parent.getChild(id).orNull();
+ return parent == null ? null : parent.getChild(id).orElse(null);
}
private static boolean canHaveChildren(@Nullable final TreeNode oldMeta, @Nullable final TreeNode newMeta) {
@Override
@Nonnull
public ModificationType getModificationType() {
- return Verify.verifyNotNull(mod.getModificationType(), "Node %s does not have resolved modification type", mod);
+ return verifyNotNull(mod.getModificationType(), "Node %s does not have resolved modification type", mod);
}
private static Optional<NormalizedNode<?, ?>> optionalData(final TreeNode meta) {
- return meta == null ? Optional.absent() : Optional.of(meta.getData());
+ return meta == null ? Optional.empty() : Optional.of(meta.getData());
}
@Override
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import java.util.Collection;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import java.util.Iterator;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
abstract class AbstractReadyIterator {
private AbstractReadyIterator(final ModifiedNode node, final Iterator<ModifiedNode> children,
final ModificationApplyOperation operation) {
- this.children = Preconditions.checkNotNull(children);
- this.node = Preconditions.checkNotNull(node);
- this.op = Preconditions.checkNotNull(operation);
+ this.children = requireNonNull(children);
+ this.node = requireNonNull(node);
+ this.op = requireNonNull(operation);
}
static AbstractReadyIterator create(final ModifiedNode root, final ModificationApplyOperation operation) {
while (children.hasNext()) {
final ModifiedNode child = children.next();
final Optional<ModificationApplyOperation> childOperation = op.getChild(child.getIdentifier());
- Preconditions.checkState(childOperation.isPresent(), "Schema for child %s is not present.",
- child.getIdentifier());
+ checkState(childOperation.isPresent(), "Schema for child %s is not present.", child.getIdentifier());
final Collection<ModifiedNode> grandChildren = child.getChildren();
final ModificationApplyOperation childOp = childOperation.get();
private NestedReadyIterator(final AbstractReadyIterator parent, final ModifiedNode node,
final Iterator<ModifiedNode> children, final ModificationApplyOperation operation) {
super(node, children, operation);
- this.parent = Preconditions.checkNotNull(parent);
+ this.parent = requireNonNull(parent);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.collect.Collections2;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
@Override
- void recursivelyVerifyStructure(NormalizedNode<?, ?> value) {
+ void recursivelyVerifyStructure(final NormalizedNode<?, ?> value) {
throw new IllegalStateException("Schema Context is not available.");
}
}
\ No newline at end of file
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicates;
import com.google.common.base.Verify;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@Override
public Optional<ModificationApplyOperation> getChild(final PathArgument child) {
- return Optional.fromNullable(childNodes.get(child));
+ return Optional.ofNullable(childNodes.get(child));
}
@Override
id);
Preconditions.checkArgument(!maybeChild.isPresent(),
"Child %s (from case %s) implies non-presence of child %s (from case %s), which is %s",
- firstChild.getIdentifier(), enforcer, id, other, maybeChild.orNull());
+ firstChild.getIdentifier(), enforcer, id, other, maybeChild.orElse(null));
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
@Override
@Nonnull
public Optional<NormalizedNode<?, ?>> getDataAfter() {
- return Optional.absent();
+ return Optional.empty();
}
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return dataOptional();
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
return NormalizedNodes.findNode(key, data, path);
}
- return Optional.absent();
+ return Optional.empty();
}
@SuppressWarnings("checkstyle:illegalCatch")
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
import java.util.Iterator;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@Override
public void exit(final int depth) {
- Preconditions.checkArgument(depth >= 0);
- Preconditions.checkState(depth < stack.size());
+ checkArgument(depth >= 0);
+ checkState(depth < stack.size());
for (int i = 0; i < depth; i++) {
stack.pop();
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
InMemoryDataTreeSnapshot(final SchemaContext schemaContext, final TreeNode rootNode,
final RootModificationApplyOperation applyOper) {
- this.schemaContext = Preconditions.checkNotNull(schemaContext);
- this.rootNode = Preconditions.checkNotNull(rootNode);
- this.applyOper = Preconditions.checkNotNull(applyOper);
+ this.schemaContext = requireNonNull(schemaContext);
+ this.rootNode = requireNonNull(rootNode);
+ this.applyOper = requireNonNull(applyOper);
}
TreeNode getRootNode() {
}
final NormalizedNode<?, ?> root = maybeRoot.get();
- Preconditions.checkArgument(root instanceof NormalizedNodeContainer, "Child %s is not a container", path);
+ checkArgument(root instanceof NormalizedNodeContainer, "Child %s is not a container", path);
return openCursor(new InMemoryDataTreeSnapshotCursor(this, path, (NormalizedNodeContainer<?, ?, ?>)root));
}
public String toString() {
return rootNode.getSubtreeVersion().toString();
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
import java.util.ArrayDeque;
import java.util.Deque;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@Override
public void enter(@Nonnull final PathArgument child) {
final Optional<NormalizedNode<?, ?>> maybeChildNode = NormalizedNodes.getDirectChild(stack.peek(), child);
- Preconditions.checkArgument(maybeChildNode.isPresent(), "Child %s not found", child);
+ checkArgument(maybeChildNode.isPresent(), "Child %s not found", child);
final NormalizedNode<?, ?> childNode = maybeChildNode.get();
- Preconditions.checkArgument(childNode instanceof NormalizedNodeContainer, "Child %s is not a container", child);
+ checkArgument(childNode instanceof NormalizedNodeContainer, "Child %s is not a container", child);
stack.push((NormalizedNodeContainer<?, ?, ?>) childNode);
}
@SuppressWarnings("checkstyle:illegalCatch")
public void enter(@Nonnull final Iterable<PathArgument> path) {
final Optional<NormalizedNode<?, ?>> maybeChildNode = NormalizedNodes.findNode(stack.peek(), path);
- Preconditions.checkArgument(maybeChildNode.isPresent(), "Child %s not found", path);
+ checkArgument(maybeChildNode.isPresent(), "Child %s not found", path);
final NormalizedNode<?, ?> childNode = maybeChildNode.get();
- Preconditions.checkArgument(childNode instanceof NormalizedNodeContainer, "Child %s is not a container", path);
+ checkArgument(childNode instanceof NormalizedNodeContainer, "Child %s is not a container", path);
int depth = 0;
for (PathArgument arg : path) {
@Override
public void exit(final int depth) {
- Preconditions.checkArgument(depth >= 0);
- Preconditions.checkState(depth < stack.size());
+ checkArgument(depth >= 0);
+ checkState(depth < stack.size());
for (int i = 0; i < depth; ++i) {
stack.pop();
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection.Builder;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
static SchemaAwareApplyOperation from(final SchemaAwareApplyOperation delegate, final DataSchemaNode schema) {
final ConstraintDefinition constraints = schema.getConstraints();
- if (constraints == null || (constraints.getMinElements() == null && constraints.getMaxElements() == null)) {
+ if (constraints == null || constraints.getMinElements() == null && constraints.getMaxElements() == null) {
return delegate;
}
return new MinMaxElementsValidation(delegate, constraints.getMinElements(), constraints.getMaxElements());
}
@Override
- void recursivelyVerifyStructure(NormalizedNode<?, ?> value) {
+ void recursivelyVerifyStructure(final NormalizedNode<?, ?> value) {
delegate.recursivelyVerifyStructure(value);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
+import java.util.function.Predicate;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@NotThreadSafe
final class ModifiedNode extends NodeModification implements StoreTreeNode<ModifiedNode> {
static final Predicate<ModifiedNode> IS_TERMINAL_PREDICATE = input -> {
- Preconditions.checkNotNull(input);
+ requireNonNull(input);
switch (input.getOperation()) {
case DELETE:
case MERGE:
*/
@Override
public Optional<ModifiedNode> getChild(final PathArgument child) {
- return Optional.fromNullable(children.get(child));
+ return Optional.ofNullable(children.get(child));
}
private Optional<TreeNode> metadataFromSnapshot(@Nonnull final PathArgument child) {
- return original.isPresent() ? original.get().getChild(child) : Optional.absent();
+ return original.isPresent() ? original.get().getChild(child) : Optional.empty();
}
private Optional<TreeNode> metadataFromData(@Nonnull final PathArgument child, final Version modVersion) {
switch (operation) {
case DELETE:
// DELETE implies non-presence
- return Optional.absent();
+ return Optional.empty();
case NONE:
case TOUCH:
case MERGE:
}
Optional<TreeNode> setSnapshot(final Optional<TreeNode> snapshot) {
- snapshotCache = Preconditions.checkNotNull(snapshot);
+ snapshotCache = requireNonNull(snapshot);
return snapshot;
}
* @param value New node value
*/
void updateValue(final LogicalOperation type, final NormalizedNode<?, ?> value) {
- this.value = Preconditions.checkNotNull(value);
+ this.value = requireNonNull(value);
updateOperationType(type);
}
}
void setValidatedNode(final SchemaAwareApplyOperation op, final Optional<TreeNode> current, final TreeNode node) {
- this.validatedOp = Preconditions.checkNotNull(op);
- this.validatedCurrent = Preconditions.checkNotNull(current);
- this.validatedNode = Preconditions.checkNotNull(node);
+ this.validatedOp = requireNonNull(op);
+ this.validatedCurrent = requireNonNull(current);
+ this.validatedNode = requireNonNull(node);
}
TreeNode getValidatedNode(final SchemaAwareApplyOperation op, final Optional<TreeNode> current) {
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import java.util.Collection;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Collections;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@Override
@Nonnull
public Optional<NormalizedNode<?, ?>> getDataAfter() {
- return Optional.absent();
+ return Optional.empty();
}
@Override
@Nonnull
public Optional<NormalizedNode<?, ?>> getDataBefore() {
- return Optional.absent();
+ return Optional.empty();
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
snapshot = applyOperation.getChild(child).get().apply(childNode, childNode.getOriginal(), version);
}
- return snapshot.transform(TreeNode::getData);
+ return snapshot.map(TreeNode::getData);
}
Optional<TreeNode> snapshot = modification.getSnapshot();
}
if (snapshot.isPresent()) {
- return snapshot.get().getChild(child).transform(TreeNode::getData);
+ return snapshot.get().getChild(child).map(TreeNode::getData);
}
- return Optional.absent();
+ return Optional.empty();
}
public ModifiedNode getModification() {
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedLeafSetNode;
}
@Override
- public Optional<ModificationApplyOperation> getChild(final YangInstanceIdentifier.PathArgument identifier) {
- if (identifier instanceof YangInstanceIdentifier.NodeWithValue) {
- return entryStrategy;
- }
- return Optional.absent();
+ public Optional<ModificationApplyOperation> getChild(final PathArgument identifier) {
+ return identifier instanceof NodeWithValue ? entryStrategy : Optional.empty();
}
}
\ No newline at end of file
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
}
@Override
- public Optional<ModificationApplyOperation> getChild(final YangInstanceIdentifier.PathArgument identifier) {
- if (identifier instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
- return entryStrategy;
- }
- return Optional.absent();
+ public Optional<ModificationApplyOperation> getChild(final PathArgument identifier) {
+ return identifier instanceof NodeIdentifierWithPredicates ? entryStrategy : Optional.empty();
}
@Override
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@Override
@Nonnull
public Optional<NormalizedNode<?, ?>> getDataAfter() {
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
DataTreeCandidateNode createLeaf(final NormalizedNode<?, ?> childData) {
return new DeleteLeafCandidateNode(childData);
}
-}
\ No newline at end of file
+}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
RecursiveReplaceCandidateNode(final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> oldData,
final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> newData) {
super(newData);
- this.oldData = Preconditions.checkNotNull(oldData);
+ this.oldData = requireNonNull(oldData);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@Override
@Nonnull
public Optional<NormalizedNode<?, ?>> getDataBefore() {
- return Optional.absent();
+ return Optional.empty();
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
ReplaceLeafCandidateNode(final NormalizedNode<?, ?> oldData, final NormalizedNode<?, ?> newData) {
super(newData);
- this.oldData = Preconditions.checkNotNull(oldData);
+ this.oldData = requireNonNull(oldData);
}
@Nonnull
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.List;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
if (containerSchema.isPresenceContainer()) {
return new PresenceContainerModificationStrategy(containerSchema, treeConfig);
}
+
return new StructuralContainerModificationStrategy(containerSchema, treeConfig);
} else if (schemaNode instanceof ListSchemaNode) {
return fromListSchemaNode((ListSchemaNode) schemaNode, treeConfig);
// Deletion of a non-existing node is a no-op, report it as such
modification.resolveModificationType(currentMeta.isPresent() ? ModificationType.DELETE
: ModificationType.UNMODIFIED);
- return modification.setSnapshot(Optional.absent());
+ return modification.setSnapshot(Optional.empty());
case TOUCH:
Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification %s",
modification);
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
*/
if (((NormalizedNodeContainer<?, ?, ?>) ret.get().getData()).getValue().isEmpty()) {
modification.resolveModificationType(ModificationType.DISAPPEARED);
- return Optional.absent();
+ return Optional.empty();
}
return ret;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@Override
public Optional<ModificationApplyOperation> getChild(final PathArgument child) {
- if (child instanceof NodeIdentifier) {
- return entryStrategy;
- }
- return Optional.absent();
+ return child instanceof NodeIdentifier ? entryStrategy : Optional.empty();
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return dataOptional();
}
-}
\ No newline at end of file
+}
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
}
@Override
- public Optional<ModificationApplyOperation> getChild(final YangInstanceIdentifier.PathArgument identifier) {
- if (identifier instanceof YangInstanceIdentifier.NodeWithValue) {
- return entryStrategy;
- }
- return Optional.absent();
+ public Optional<ModificationApplyOperation> getChild(final PathArgument identifier) {
+ return identifier instanceof NodeWithValue ? entryStrategy : Optional.empty();
}
}
\ No newline at end of file
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
// we get from it.
return entryStrategy.get().getChild(identifier);
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@Override
@Nonnull
public Optional<NormalizedNode<?, ?>> getDataBefore() {
- return Optional.absent();
+ return Optional.empty();
}
-}
\ No newline at end of file
+}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import com.google.common.collect.Sets;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
.build();
AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(myDoublyKeyedList)))
+ new AugmentationIdentifier(Collections.singleton(myDoublyKeyedList)))
.withChild(myDoublyKeyedListNode).build();
ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
.withChild(myDoublyKeyedListAugNode).build();
AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(myContainer3)))
+ new AugmentationIdentifier(Collections.singleton(myContainer3)))
.withChild(myContainer3Node).build();
ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
+import static com.google.common.base.Preconditions.checkState;
+
import java.io.File;
import java.io.FileNotFoundException;
import java.net.URI;
AugmentationNode augmentation = Builders
.augmentationBuilder()
.withNodeIdentifier(
- new AugmentationIdentifier(Sets.newHashSet(getQName("augmentUint32"))))
+ new AugmentationIdentifier(Collections.singleton(getQName("augmentUint32"))))
.withChild(
Builders.<Integer>leafBuilder().withNodeIdentifier(getNodeIdentifier("augmentUint32"))
.withValue(11).build()).build();
for (Module module : context.getModules()) {
if (module.getName().equals(moduleName)) {
DataSchemaNode found = findChildNode(module.getChildNodes(), childNodeName);
- Preconditions.checkState(found != null, "Unable to find %s", childNodeName);
+ checkState(found != null, "Unable to find %s", childNodeName);
return found;
}
}
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import java.io.File;
import java.net.URI;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
-import com.google.common.base.Optional;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- final Optional<TreeNode> node = StoreTreeNodes.getChild(Optional.fromNullable(rootNode),
+ final Optional<TreeNode> node = StoreTreeNodes.getChild(Optional.ofNullable(rootNode),
TestModel.TEST_PATH.getLastPathArgument());
assertPresentAndType(node, TreeNode.class);
}
final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- final Optional<TreeNode> node = StoreTreeNodes.getChild(Optional.fromNullable(rootNode),
+ final Optional<TreeNode> node = StoreTreeNodes.getChild(Optional.ofNullable(rootNode),
TestModel.OUTER_LIST_PATH.getLastPathArgument());
assertFalse(node.isPresent());
}
*/
package org.opendaylight.yangtools.yang.data.jaxen;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Converter;
-import com.google.common.base.Preconditions;
import javax.annotation.Nonnull;
import org.jaxen.NamespaceContext;
import org.opendaylight.yangtools.yang.common.QName;
final class ConverterNamespaceContext extends Converter<String, QNameModule> implements NamespaceContext {
private final Converter<String, QNameModule> delegate;
- ConverterNamespaceContext(final Converter<String, QNameModule> convertor) {
- this.delegate = Preconditions.checkNotNull(convertor);
+ ConverterNamespaceContext(final Converter<String, QNameModule> converter) {
+ this.delegate = requireNonNull(converter);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.jaxen;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Optional;
import org.jaxen.expr.AllNodeStep;
import org.jaxen.expr.BinaryExpr;
private final ExprListener listener;
ExprWalker(final ExprListener listener) {
- this.listener = Preconditions.checkNotNull(listener);
+ this.listener = requireNonNull(listener);
}
public void walk(final Expr expr) {
*/
package org.opendaylight.yangtools.yang.data.jaxen;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.xpath.XPathDocument;
private final SchemaContext context;
JaxenDocument(final JaxenSchemaContext context, final NormalizedNode<?, ?> root) {
- this.root = Preconditions.checkNotNull(root);
+ this.root = requireNonNull(root);
this.context = context.getSchemaContext();
}
*/
package org.opendaylight.yangtools.yang.data.jaxen;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Converter;
-import com.google.common.base.Preconditions;
import javax.annotation.Nonnull;
import javax.xml.xpath.XPathExpressionException;
import org.jaxen.JaxenException;
final class JaxenSchemaContext implements XPathSchemaContext {
// Will be needed for compileExpression()
- @SuppressWarnings("unused")
private final SchemaContext context;
JaxenSchemaContext(final SchemaContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
}
@Nonnull
*/
package org.opendaylight.yangtools.yang.data.jaxen;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Converter;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.xml.xpath.XPathExpressionException;
import org.jaxen.BaseXPath;
private JaxenXPath(final Converter<String, QNameModule> converter, final SchemaPath schemaPath,
final BaseXPath xpath) {
- this.converter = Preconditions.checkNotNull(converter);
- this.schemaPath = Preconditions.checkNotNull(schemaPath);
- this.xpath = Preconditions.checkNotNull(xpath);
+ this.converter = requireNonNull(converter);
+ this.schemaPath = requireNonNull(schemaPath);
+ this.xpath = requireNonNull(xpath);
}
static JaxenXPath create(final Converter<String, QNameModule> converter, final SchemaPath schemaPath,
@Override
public Optional<? extends XPathResult<?>> evaluate(@Nonnull final XPathDocument document,
@Nonnull final YangInstanceIdentifier path) throws XPathExpressionException {
- Preconditions.checkArgument(document instanceof JaxenDocument);
+ checkArgument(document instanceof JaxenDocument);
final NormalizedNodeContextSupport contextSupport = NormalizedNodeContextSupport.create(
(JaxenDocument)document, converter);
return Lists.transform((List<NormalizedNodeContext>) result, NormalizedNodeContext::getNode);
});
} else {
- return Optional.absent();
+ return Optional.empty();
}
}
import com.google.common.annotations.Beta;
import com.google.common.base.CharMatcher;
-import com.google.common.base.Optional;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.RegEx;
*/
package org.opendaylight.yangtools.yang.data.jaxen;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Function;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
NormalizedNodeContext(@Nonnull final ContextSupport contextSupport, @Nonnull final NormalizedNode<?, ?> node,
@Nullable final NormalizedNodeContext parent) {
super(contextSupport);
- this.node = Preconditions.checkNotNull(node);
+ this.node = requireNonNull(node);
this.parent = parent;
setNodeSet(ImmutableList.of(this));
*/
package org.opendaylight.yangtools.yang.data.jaxen;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Converter;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import java.util.Optional;
import org.jaxen.ContextSupport;
import org.jaxen.SimpleVariableContext;
import org.opendaylight.yangtools.yang.common.QNameModule;
NormalizedNodeContext result = root;
for (PathArgument arg : path.getPathArguments()) {
final Optional<NormalizedNode<?, ?>> node = NormalizedNodes.getDirectChild(result.getNode(), arg);
- Preconditions.checkArgument(node.isPresent(), "Node %s has no child %s", result.getNode(), arg);
+ checkArgument(node.isPresent(), "Node %s has no child %s", result.getNode(), arg);
result = new NormalizedNodeContext(this, node.get(), result);
}
*/
package org.opendaylight.yangtools.yang.data.jaxen;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Joiner;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import com.google.common.collect.Iterators;
import com.google.common.collect.UnmodifiableIterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import org.jaxen.DefaultNavigator;
private final JaxenDocument document;
NormalizedNodeNavigator(final ConverterNamespaceContext context, final JaxenDocument document) {
- this.namespaceContext = Preconditions.checkNotNull(context);
+ this.namespaceContext = requireNonNull(context);
this.document = document;
}
private NormalizedNodeContext next;
NormalizedNodeContextIterator(final NormalizedNodeContext initial) {
- this.next = Preconditions.checkNotNull(initial);
+ this.next = requireNonNull(initial);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.jaxen;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Verify;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import org.jaxen.ContextSupport;
import org.jaxen.Function;
import static org.mockito.Mockito.mock;
import com.google.common.base.Converter;
-import com.google.common.base.Optional;
import com.google.common.base.VerifyException;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import javax.xml.xpath.XPathExpressionException;
import org.jaxen.Context;
import org.jaxen.Function;
*/
package org.opendaylight.yangtools.yang.data.util;
-import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import com.google.common.annotations.Beta;
import javax.annotation.Nonnull;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
@Override
protected final QName createQName(@Nonnull final String prefix, @Nonnull final String localName) {
final Module module = moduleForPrefix(prefix);
- Preconditions.checkArgument(module != null, "Failed to lookup prefix %s", prefix);
+ checkArgument(module != null, "Failed to lookup prefix %s", prefix);
return QName.create(module.getQNameModule(), localName);
}
}
*/
package org.opendaylight.yangtools.yang.data.util;
-import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import com.google.common.annotations.Beta;
import javax.annotation.Nonnull;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
@Override
protected final QName createQName(@Nonnull final String prefix, @Nonnull final String localName) {
final Module module = moduleForPrefix(prefix);
- Preconditions.checkArgument(module != null, "Failed to lookup prefix %s", prefix);
+ checkArgument(module != null, "Failed to lookup prefix %s", prefix);
return QName.create(module.getQNameModule(), localName);
}
}
*/
package org.opendaylight.yangtools.yang.data.util;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Splitter;
import java.net.URI;
import java.util.Iterator;
protected final StringBuilder appendQName(final StringBuilder sb, final QName qname) {
final String prefix = prefixForNamespace(qname.getNamespace());
- Preconditions.checkArgument(prefix != null, "Failed to map QName {}", qname);
+ checkArgument(prefix != null, "Failed to map QName {}", qname);
sb.append(prefix);
sb.append(':');
sb.append(qname.getLocalName());
*/
package org.opendaylight.yangtools.yang.data.util;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.io.IOException;
import java.util.Map;
import java.util.Objects;
private Map<QName, String> attributes;
public AbstractNodeDataWithSchema(final DataSchemaNode schema) {
- this.schema = Preconditions.checkNotNull(schema);
+ this.schema = requireNonNull(schema);
}
/**
* @param attributes parsed attributes
*/
public final void setAttributes(final Map<QName, String> attributes) {
- Preconditions.checkState(this.attributes == null, "Node '%s' has already set its attributes to %s.",
- getSchema().getQName(), this.attributes);
+ checkState(this.attributes == null, "Node '%s' has already set its attributes to %s.", getSchema().getQName(),
+ this.attributes);
this.attributes = attributes;
}
*/
package org.opendaylight.yangtools.yang.data.util;
+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;
import java.util.Map;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
DataSchemaContextNode<?> current = getDataContextTree().getRoot();
for (PathArgument arg : data.getPathArguments()) {
current = current.getChild(arg);
- Preconditions.checkArgument(current != null,
- "Invalid input %s: schema for argument %s (after %s) not found", data, arg, sb);
+ checkArgument(current != null, "Invalid input %s: schema for argument %s (after %s) not found", data, arg,
+ sb);
if (current.isMixin()) {
/*
@Override
public final YangInstanceIdentifier deserialize(final String data) {
- Preconditions.checkNotNull(data, "Data may not be null");
- XpathStringParsingPathArgumentBuilder builder = new XpathStringParsingPathArgumentBuilder(this, data);
+ XpathStringParsingPathArgumentBuilder builder = new XpathStringParsingPathArgumentBuilder(this,
+ requireNonNull(data));
return YangInstanceIdentifier.create(builder.build());
}
-
}
package org.opendaylight.yangtools.yang.data.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yangtools.concepts.Codec;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
protected final UnionTypeDefinition typeDefinition;
protected AbstractStringUnionCodec(final DataSchemaNode schema, final UnionTypeDefinition typeDefinition) {
- this.schema = Preconditions.checkNotNull(schema);
- this.typeDefinition = Preconditions.checkNotNull(typeDefinition);
+ this.schema = requireNonNull(schema);
+ this.typeDefinition = requireNonNull(typeDefinition);
}
protected abstract Codec<String, Object> codecFor(TypeDefinition<?> type);
package org.opendaylight.yangtools.yang.data.util;
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Interner;
import com.google.common.collect.Interners;
+import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
}
}
- return Preconditions::checkNotNull;
+ return Objects::requireNonNull;
}
}
*/
package org.opendaylight.yangtools.yang.data.util;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkState;
+
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
return;
}
- Preconditions.checkState(keyDef.size() == qnameToKeys.size(), "Input is missing some of the keys of %s",
+ checkState(keyDef.size() == qnameToKeys.size(), "Input is missing some of the keys of %s",
getSchema().getQName());
// Need to restore schema order...
package org.opendaylight.yangtools.yang.data.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.net.URI;
import javax.annotation.Nonnull;
-
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.codec.IdentityrefCodec;
import org.opendaylight.yangtools.yang.model.api.Module;
protected final QNameModule parentModuleQname;
public ModuleStringIdentityrefCodec(@Nonnull final SchemaContext context, @Nonnull final QNameModule parentModule) {
- this.context = Preconditions.checkNotNull(context);
- this.parentModuleQname = Preconditions.checkNotNull(parentModule);
+ this.context = requireNonNull(context);
+ this.parentModuleQname = requireNonNull(parentModule);
}
@Override
*/
package org.opendaylight.yangtools.yang.data.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.CharMatcher;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.ArrayList;
private int offset;
XpathStringParsingPathArgumentBuilder(final AbstractStringInstanceIdentifierCodec codec, final String data) {
- this.codec = Preconditions.checkNotNull(codec);
- this.data = Preconditions.checkNotNull(data);
+ this.codec = requireNonNull(codec);
+ this.data = requireNonNull(data);
this.current = codec.getDataContextTree().getRoot();
this.offset = 0;
}
*/
package org.opendaylight.yangtools.yang.data.util.codec;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
import java.util.ArrayList;
import java.util.List;
import javax.annotation.concurrent.ThreadSafe;
private final SchemaContext schemaContext;
protected AbstractCodecFactory(final SchemaContext schemaContext, final CodecCache<T> cache) {
- this.schemaContext = Preconditions.checkNotNull(schemaContext);
- this.cache = Preconditions.checkNotNull(cache);
+ this.schemaContext = requireNonNull(schemaContext);
+ this.cache = requireNonNull(cache);
}
public final SchemaContext getSchemaContext() {
return null;
}
- return cache.getSimple(type, Verify.verifyNotNull(ret));
+ return cache.getSimple(type, verifyNotNull(ret));
}
private static boolean isSimpleUnion(final UnionTypeDefinition union) {
for (TypeDefinition<?> t : union.getTypes()) {
if (t instanceof IdentityrefTypeDefinition || t instanceof LeafrefTypeDefinition
- || (t instanceof UnionTypeDefinition && !isSimpleUnion((UnionTypeDefinition) t))) {
+ || t instanceof UnionTypeDefinition && !isSimpleUnion((UnionTypeDefinition) t)) {
LOG.debug("Type {} has non-simple subtype", t);
return false;
}
} else if (type instanceof LeafrefTypeDefinition) {
final TypeDefinition<?> target = SchemaContextUtil.getBaseTypeForLeafRef((LeafrefTypeDefinition) type,
schemaContext, schema);
- Verify.verifyNotNull(target, "Unable to find base type for leafref node %s type %s.", schema.getPath(),
+ verifyNotNull(target, "Unable to find base type for leafref node %s type %s.", schema.getPath(),
target);
final T ret = getSimpleCodecFor(target);
for (TypeDefinition<?> type : types) {
T codec = cache.lookupSimple(type);
if (codec == null) {
- codec = Verify.verifyNotNull(getSimpleCodecFor(type), "Type %s did not resolve to a simple codec",
- type);
+ codec = verifyNotNull(getSimpleCodecFor(type), "Type %s did not resolve to a simple codec", type);
}
codecs.add(codec);
}
}
- codecs.add(Verify.verifyNotNull(codec, "Schema %s subtype %s has no codec", schema, type));
+ codecs.add(verifyNotNull(codec, "Schema %s subtype %s has no codec", schema, type));
}
return unionCodec(union, codecs);
*/
package org.opendaylight.yangtools.yang.data.util.codec;
+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;
import java.util.Map;
import javax.annotation.concurrent.ThreadSafe;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
private final Map<TypedSchemaNode, T> complexCodecs;
PrecomputedCodecCache(final Map<TypeDefinition<?>, T> simpleCodecs, final Map<TypedSchemaNode, T> complexCodecs) {
- this.simpleCodecs = Preconditions.checkNotNull(simpleCodecs);
- this.complexCodecs = Preconditions.checkNotNull(complexCodecs);
+ this.simpleCodecs = requireNonNull(simpleCodecs);
+ this.complexCodecs = requireNonNull(complexCodecs);
}
@Override
T lookupComplex(final TypedSchemaNode schema) {
final T ret = complexCodecs.get(schema);
- Preconditions.checkArgument(ret != null, "No codec available for schema %s", schema);
+ checkArgument(ret != null, "No codec available for schema %s", schema);
return ret;
}
*/
package org.opendaylight.yangtools.yang.data.util.codec;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import java.util.Iterator;
import java.util.function.Function;
// It is "prefix:value"
prefix = first;
identifier = it.next();
- Preconditions.checkArgument(!it.hasNext(), "Malformed QName '" + str + "'");
+ checkArgument(!it.hasNext(), "Malformed QName '%s'", str);
} else {
prefix = "";
identifier = first;
}
final QNameModule module = prefixToModule.apply(prefix);
- Preconditions.checkArgument(module != null, "Cannot resolve prefix '%s' from %s", prefix, str);
+ checkArgument(module != null, "Cannot resolve prefix '%s' from %s", prefix, str);
return QName.create(module, identifier);
}
public static String encodeQName(final QName qname, final Function<QNameModule, String> moduleToPrefix) {
final String prefix = moduleToPrefix.apply(qname.getModule());
- Preconditions.checkArgument(prefix != null, "Cannot allocated prefix for %s", qname);
+ checkArgument(prefix != null, "Cannot allocated prefix for %s", qname);
return prefix.isEmpty() ? qname.getLocalName() : prefix + ":" + qname.getLocalName();
}
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
private static void checkArtifact(final Artifact artifact, final Collection<Artifact> dependencies) {
for (org.apache.maven.artifact.Artifact d : dependencies) {
if (artifact.getGroupId().equals(d.getGroupId()) && artifact.getArtifactId().equals(d.getArtifactId())) {
- if (!(artifact.getVersion().equals(d.getVersion()))) {
+ if (!artifact.getVersion().equals(d.getVersion())) {
LOG.warn("{} Dependency resolution conflict:", LOG_PREFIX);
LOG.warn("{} '{}' dependency [{}] has different version than one declared in current project [{}]"
+ ". It is recommended to fix this problem because it may cause compilation errors.",
static SourceIdentifier moduleToIdentifier(final Module module) {
final QNameModule mod = module.getQNameModule();
final Date rev = mod.getRevision();
- final com.google.common.base.Optional<String> optRev;
+ final Optional<String> optRev;
if (SimpleDateFormatUtil.DEFAULT_DATE_REV.equals(rev)) {
- optRev = com.google.common.base.Optional.absent();
+ optRev = Optional.empty();
} else {
- optRev = com.google.common.base.Optional.of(mod.getFormattedRevision());
+ optRev = Optional.of(mod.getFormattedRevision());
}
return RevisionSourceIdentifier.create(module.getName(), optRev);
*/
package org.opendaylight.yangtools.yang.model.api;
-import com.google.common.base.Optional;
import java.util.List;
+import java.util.Optional;
/**
* AugmentationSchema represents augment definition. The "augment" statement
*/
package org.opendaylight.yangtools.yang.model.api;
-import com.google.common.base.Optional;
+import java.util.Optional;
/**
* Schema Node which may be derived from other schema node
package org.opendaylight.yangtools.yang.model.api;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
/**
* Enum describing YANG deviation 'deviate' statement. It defines how the
private final String keyword;
DeviateKind(final String keyword) {
- this.keyword = Preconditions.checkNotNull(keyword);
+ this.keyword = requireNonNull(keyword);
}
/**
*/
package org.opendaylight.yangtools.yang.model.api;
-import com.google.common.base.Optional;
import com.google.common.collect.Sets;
import java.net.URI;
import java.util.Date;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.concurrent.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
Module findModuleByName(String name, Date revision);
default Optional<Module> findAnyModuleByName(final String name) {
- return Optional.fromNullable(findModuleByName(name, null));
+ return Optional.ofNullable(findModuleByName(name, null));
}
/**
*/
package org.opendaylight.yangtools.yang.model.api;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
@Override
protected SchemaPath createInstance(final SchemaPath parent, final QName qname) {
- return new AbsoluteSchemaPath(parent, Preconditions.checkNotNull(qname));
+ return new AbsoluteSchemaPath(parent, requireNonNull(qname));
}
}
@Override
protected SchemaPath createInstance(final SchemaPath parent, final QName qname) {
- return new RelativeSchemaPath(parent, Preconditions.checkNotNull(qname));
+ return new RelativeSchemaPath(parent, requireNonNull(qname));
}
}
* @return A new child path
*/
public SchemaPath createChild(final SchemaPath relative) {
- Preconditions.checkArgument(!relative.isAbsolute(), "Child creation requires relative path");
+ checkArgument(!relative.isAbsolute(), "Child creation requires relative path");
SchemaPath parentPath = this;
for (QName qname : relative.getPathFromRoot()) {
*/
package org.opendaylight.yangtools.yang.model.api;
-import com.google.common.base.Optional;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
* @return Optional of XPath condition
*/
default @Nonnull Optional<RevisionAwareXPath> getWhenCondition() {
- return Optional.absent();
+ return Optional.empty();
}
}
*/
package org.opendaylight.yangtools.yang.model.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;
import org.opendaylight.yangtools.yang.common.QName;
private final boolean yinElement;
YangStmtMapping(final Class<? extends DeclaredStatement<?>> clz, final String nameStr) {
- type = Preconditions.checkNotNull(clz);
+ type = requireNonNull(clz);
//FIXME: fill up effective type correctly
effectiveType = null;
name = yinQName(nameStr);
}
YangStmtMapping(final Class<? extends DeclaredStatement<?>> clz, final String nameStr, final String argumentStr) {
- type = Preconditions.checkNotNull(clz);
+ type = requireNonNull(clz);
//FIXME: fill up effective type correctly
effectiveType = null;
name = yinQName(nameStr);
YangStmtMapping(final Class<? extends DeclaredStatement<?>> clz, final String nameStr, final String argumentStr,
final boolean yinElement) {
- type = Preconditions.checkNotNull(clz);
+ type = requireNonNull(clz);
//FIXME: fill up effective type correctly
effectiveType = null;
name = yinQName(nameStr);
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.UnmodifiableIterator;
@Override
protected SchemaNodeIdentifier createInstance(final SchemaNodeIdentifier parent, final QName qname) {
- return new Absolute(parent, Preconditions.checkNotNull(qname));
+ return new Absolute(parent, requireNonNull(qname));
}
}
@Override
protected SchemaNodeIdentifier createInstance(final SchemaNodeIdentifier parent, final QName qname) {
- return new Relative(parent, Preconditions.checkNotNull(qname));
+ return new Relative(parent, requireNonNull(qname));
}
}
* @return A new child path
*/
public SchemaNodeIdentifier createChild(final SchemaNodeIdentifier relative) {
- Preconditions.checkArgument(!relative.isAbsolute(), "Child creation requires relative path");
+ checkArgument(!relative.isAbsolute(), "Child creation requires relative path");
SchemaNodeIdentifier parentNode = this;
for (QName qname : relative.getPathFromRoot()) {
package org.opendaylight.yangtools.yang.model.api.type;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Maps;
import java.util.Arrays;
import java.util.Map;
private final String keyword;
ModifierKind(final String keyword) {
- this.keyword = Preconditions.checkNotNull(keyword);
+ this.keyword = requireNonNull(keyword);
}
/**
* @throws NullPointerException if keyword is null
*/
public static Optional<ModifierKind> parse(final String keyword) {
- return Optional.ofNullable(MODIFIER_KIND_MAP.get(Preconditions.checkNotNull(keyword)));
+ return Optional.ofNullable(MODIFIER_KIND_MAP.get(requireNonNull(keyword)));
}
}
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.io.ByteSource;
import java.io.IOException;
import java.io.InputStream;
DelegatedYangTextSchemaSource(final SourceIdentifier identifier, final ByteSource delegate) {
super(identifier);
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
}
@Override
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
/**
* Exception thrown when a the specified schema source is not available.
}
public MissingSchemaSourceException(final String message, final SourceIdentifier id, final Throwable cause) {
- super(message, cause);
- this.id = Preconditions.checkNotNull(id);
+ super(requireNonNull(message), cause);
+ this.id = requireNonNull(id);
}
public SourceIdentifier getSourceId() {
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
ResourceYangTextSchemaSource(final SourceIdentifier identifier, final URL url) {
super(identifier);
- this.url = Preconditions.checkNotNull(url);
+ this.url = requireNonNull(url);
}
@Override
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.util.Objects;
+import java.util.Optional;
/**
* YANG Schema revision source identifier.
* Revision of source in format YYYY-mm-dd
*/
RevisionSourceIdentifier(final String name, final String formattedRevision) {
- super(Preconditions.checkNotNull(name), Preconditions.checkNotNull(formattedRevision));
+ super(requireNonNull(name), requireNonNull(formattedRevision));
}
/**
package org.opendaylight.yangtools.yang.model.repo.api;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.model.api.Module;
* semantic version of source
*/
SemVerSourceIdentifier(final String name, final SemVer semVer) {
- this(name, Optional.absent(), semVer);
+ this(name, Optional.empty(), semVer);
}
/**
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Interner;
import com.google.common.collect.Interners;
+import java.util.Optional;
import java.util.regex.Pattern;
import javax.annotation.RegEx;
import org.opendaylight.yangtools.concepts.Identifier;
* Name of schema
*/
SourceIdentifier(final String name) {
- this.name = Preconditions.checkNotNull(name);
+ this.name = requireNonNull(name);
this.revision = null;
}
* Revision of source in format YYYY-mm-dd
*/
SourceIdentifier(final String name, final String formattedRevision) {
- this.name = Preconditions.checkNotNull(name);
- this.revision = Preconditions.checkNotNull(formattedRevision);
+ this.name = requireNonNull(name);
+ this.revision = requireNonNull(formattedRevision);
}
/**
* default value will be used.
*/
SourceIdentifier(final String name, final Optional<String> formattedRevision) {
- this.name = Preconditions.checkNotNull(name);
- this.revision = formattedRevision.orNull();
+ this.name = requireNonNull(name);
+ this.revision = formattedRevision.orElse(null);
}
/**
*/
public String toYangFilename() {
final String rev = NOT_PRESENT_FORMATTED_REVISION.equals(revision) ? null : revision;
- return toYangFileName(name, Optional.fromNullable(rev));
+ return toYangFileName(name, Optional.ofNullable(rev));
}
/**
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
YangTextFileSchemaSource(final SourceIdentifier identifier, final File file) {
super(identifier);
- this.file = Preconditions.checkNotNull(file);
+ this.file = requireNonNull(file);
}
@Override
package org.opendaylight.yangtools.yang.model.repo.api;
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.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.io.ByteSource;
import com.google.common.io.Resources;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.util.Map.Entry;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.common.YangNames;
private final SourceIdentifier identifier;
protected YangTextSchemaSource(final SourceIdentifier identifier) {
- this.identifier = Preconditions.checkNotNull(identifier);
+ this.identifier = requireNonNull(identifier);
}
public static SourceIdentifier identifierFromFilename(final String name) {
final String baseName = name.substring(0, name.length() - YangConstants.RFC6020_YANG_FILE_EXTENSION.length());
final Entry<String, String> parsed = YangNames.parseFilename(baseName);
- return RevisionSourceIdentifier.create(parsed.getKey(), Optional.fromNullable(parsed.getValue()));
+ return RevisionSourceIdentifier.create(parsed.getKey(), Optional.ofNullable(parsed.getValue()));
}
/**
* @throws NullPointerException if file is null
*/
public static YangTextSchemaSource forFile(final File file) {
- Preconditions.checkArgument(file.isFile(), "Supplied file %s is not a file", file);
+ checkArgument(file.isFile(), "Supplied file %s is not a file");
return new YangTextFileSchemaSource(identifierFromFilename(file.getName()), file);
}
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.common.YangConstants.RFC6020_YIN_MODULE;
import static org.opendaylight.yangtools.yang.model.api.YangStmtMapping.MODULE;
import static org.opendaylight.yangtools.yang.model.api.YangStmtMapping.REVISION;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerException;
}
final QName qname = QName.create(rootNs, root.getLocalName());
- Preconditions.checkArgument(RFC6020_YIN_MODULE.equals(qname.getModule()),
+ checkArgument(RFC6020_YIN_MODULE.equals(qname.getModule()),
"Root node namepsace %s does not match %s", rootNs, YangConstants.RFC6020_YIN_NAMESPACE);
- Preconditions.checkArgument(MODULE.getStatementName().equals(qname)
+ checkArgument(MODULE.getStatementName().equals(qname)
|| SUBMODULE.getStatementName().equals(qname), "Root element %s is not a module nor a submodule", qname);
- Preconditions.checkArgument(root instanceof Element, "Root node %s is not an element", root);
+ checkArgument(root instanceof Element, "Root node %s is not an element", root);
final Element element = (Element)root;
final Attr nameAttr = element.getAttributeNode(MODULE.getArgumentName().getLocalName());
- Preconditions.checkArgument(nameAttr != null, "No %s name argument found in %s", element.getLocalName());
+ checkArgument(nameAttr != null, "No %s name argument found in %s", element.getLocalName());
final NodeList revisions = element.getElementsByTagNameNS(REVISION_STMT.getNamespace().toString(),
REVISION_STMT.getLocalName());
final Element revisionStmt = (Element) revisions.item(0);
final Attr dateAttr = revisionStmt.getAttributeNode(REVISION.getArgumentName().getLocalName());
- Preconditions.checkArgument(dateAttr != null, "No revision statement argument found in %s", revisionStmt);
+ checkArgument(dateAttr != null, "No revision statement argument found in %s", revisionStmt);
final SourceIdentifier parsedId = RevisionSourceIdentifier.create(nameAttr.getValue(),
Optional.of(dateAttr.getValue()));
private final DOMSource source;
Simple(@Nonnull final SourceIdentifier identifier, @Nonnull final DOMSource source) {
- this.identifier = Preconditions.checkNotNull(identifier);
- this.source = Preconditions.checkNotNull(source);
+ this.identifier = requireNonNull(identifier);
+ this.source = requireNonNull(source);
}
@Nonnull
private volatile DOMSource source;
Transforming(final YinXmlSchemaSource xmlSchemaSource) {
- this.xmlSchemaSource = Preconditions.checkNotNull(xmlSchemaSource);
+ this.xmlSchemaSource = requireNonNull(xmlSchemaSource);
}
@Nonnull
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+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.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.io.ByteSource;
import com.google.common.io.Resources;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.util.Map.Entry;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.yang.common.YangConstants;
private final SourceIdentifier identifier;
protected YinTextSchemaSource(final SourceIdentifier identifier) {
- this.identifier = Preconditions.checkNotNull(identifier);
+ this.identifier = requireNonNull(identifier);
}
public static SourceIdentifier identifierFromFilename(final String name) {
}
final Entry<String, String> parsed = YangNames.parseFilename(baseName);
- return RevisionSourceIdentifier.create(parsed.getKey(), Optional.fromNullable(parsed.getValue()));
+ return RevisionSourceIdentifier.create(parsed.getKey(), Optional.ofNullable(parsed.getValue()));
}
@Override
}
public static YinTextSchemaSource forFile(final File file) {
- Preconditions.checkArgument(file.isFile(), "Supplied file %s is not a file", file);
+ checkArgument(file.isFile(), "Supplied file %s is not a file", file);
return new YinTextFileSchemaSource(identifierFromFilename(file.getName()), file);
}
private DelegatedYinTextSchemaSource(final SourceIdentifier identifier, final ByteSource delegate) {
super(identifier);
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
}
@Override
*/
package org.opendaylight.yangtools.yang.model.repo.spi;
+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;
import com.google.common.collect.Interner;
import com.google.common.collect.Interners;
import java.util.Objects;
private PotentialSchemaSource(final SourceIdentifier sourceIdentifier, final Class<? extends T> representation,
final int cost) {
- this.representation = Preconditions.checkNotNull(representation);
- this.sourceIdentifier = Preconditions.checkNotNull(sourceIdentifier);
- Preconditions.checkArgument(cost >= 0, "cost has to be non-negative");
+ this.representation = requireNonNull(representation);
+ this.sourceIdentifier = requireNonNull(sourceIdentifier);
+ checkArgument(cost >= 0, "cost has to be non-negative");
this.cost = cost;
}
package org.opendaylight.yangtools.yang.model.export;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicates;
import com.google.common.base.Strings;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
*/
package org.opendaylight.yangtools.yang.model.immutable;
-import com.google.common.base.Optional;
import java.util.Date;
+import java.util.Optional;
import org.immutables.value.Value;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
*/
package org.opendaylight.yangtools.yang.model.repo.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
protected AbstractSchemaSourceCache(final SchemaSourceRegistry consumer, final Class<T> representation,
final Costs cost) {
- this.consumer = Preconditions.checkNotNull(consumer);
- this.representation = Preconditions.checkNotNull(representation);
- this.cost = Preconditions.checkNotNull(cost);
+ this.consumer = requireNonNull(consumer);
+ this.representation = requireNonNull(representation);
+ this.cost = requireNonNull(cost);
}
/**
*/
package org.opendaylight.yangtools.yang.model.repo.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
protected AbstractSchemaSourceRegistration(final SchemaSourceProvider<?> provider,
final PotentialSchemaSource<T> source) {
super(source);
- this.provider = Preconditions.checkNotNull(provider);
+ this.provider = requireNonNull(provider);
}
protected final SchemaSourceProvider<?> getProvider() {
*/
package org.opendaylight.yangtools.yang.model.repo.util;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.CheckedFuture;
import java.util.Date;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
final SchemaSourceRegistry consumer, final Class<T> representation, final File storageDirectory) {
super(consumer, representation, Costs.LOCAL_IO);
this.representation = representation;
- this.storageDirectory = Preconditions.checkNotNull(storageDirectory);
+ this.storageDirectory = requireNonNull(storageDirectory);
checkSupportedRepresentation(representation);
if (!storageDirectory.exists()) {
- Preconditions.checkArgument(storageDirectory.mkdirs(), "Unable to create cache directory at %s",
- storageDirectory);
+ checkArgument(storageDirectory.mkdirs(), "Unable to create cache directory at %s", storageDirectory);
}
- Preconditions.checkArgument(storageDirectory.exists());
- Preconditions.checkArgument(storageDirectory.isDirectory());
- Preconditions.checkArgument(storageDirectory.canWrite());
- Preconditions.checkArgument(storageDirectory.canRead());
+ checkArgument(storageDirectory.exists());
+ checkArgument(storageDirectory.isDirectory());
+ checkArgument(storageDirectory.canWrite());
+ checkArgument(storageDirectory.canRead());
init();
}
}
void store(final File file, final SchemaSourceRepresentation schemaSourceRepresentation) {
- Preconditions.checkArgument(supportedType.isAssignableFrom(schemaSourceRepresentation.getClass()),
+ checkArgument(supportedType.isAssignableFrom(schemaSourceRepresentation.getClass()),
"Cannot store schema source %s, this adapter only supports %s", schemaSourceRepresentation,
supportedType);
protected abstract void storeAsType(File file, T cast);
public T restore(final SourceIdentifier sourceIdentifier, final File cachedSource) {
- Preconditions.checkArgument(cachedSource.isFile());
- Preconditions.checkArgument(cachedSource.exists());
- Preconditions.checkArgument(cachedSource.canRead());
+ checkArgument(cachedSource.isFile());
+ checkArgument(cachedSource.exists());
+ checkArgument(cachedSource.canRead());
return restoreAsType(sourceIdentifier, cachedSource);
}
if (matcher.matches()) {
final String moduleName = matcher.group("moduleName");
final String revision = matcher.group("revision");
- return Optional.of(RevisionSourceIdentifier.create(moduleName, Optional.fromNullable(revision)));
+ return Optional.of(RevisionSourceIdentifier.create(moduleName, Optional.ofNullable(revision)));
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
*/
package org.opendaylight.yangtools.yang.model.repo.util;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistration;
private int refcount = 1;
RefcountedRegistration(final SchemaSourceRegistration<?> reg) {
- this.reg = Preconditions.checkNotNull(reg);
+ this.reg = requireNonNull(reg);
}
public void incRef() {
}
public boolean decRef() {
- Preconditions.checkState(refcount > 0, "Refcount underflow: %s", refcount);
+ checkState(refcount > 0, "Refcount underflow: %s", refcount);
if (0 == --refcount) {
reg.close();
return true;
- } else {
- return false;
}
+
+ return false;
}
}
\ No newline at end of file
*/
package org.opendaylight.yangtools.yang.model.repo.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
public SchemaSourceTransformer(final SchemaRepository provider, final Class<S> srcClass,
final SchemaSourceRegistry consumer, final Class<D> dstClass, final AsyncFunction<S, D> function) {
- this.provider = Preconditions.checkNotNull(provider);
- this.consumer = Preconditions.checkNotNull(consumer);
- this.function = Preconditions.checkNotNull(function);
- this.srcClass = Preconditions.checkNotNull(srcClass);
- this.dstClass = Preconditions.checkNotNull(dstClass);
+ this.provider = requireNonNull(provider);
+ this.consumer = requireNonNull(consumer);
+ this.function = requireNonNull(function);
+ this.srcClass = requireNonNull(srcClass);
+ this.dstClass = requireNonNull(dstClass);
}
@Override
package org.opendaylight.yangtools.yang.model.util;
-import com.google.common.base.Optional;
-import com.google.common.base.Supplier;
import com.google.common.collect.SetMultimap;
import java.net.URI;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-
public abstract class AbstractSchemaContext implements SchemaContext {
protected static final Comparator<Module> REVISION_COMPARATOR = (o1, o2) -> {
if (o2.getRevision() == null) {
return o2.getRevision().compareTo(o1.getRevision());
};
- protected static final Supplier<TreeSet<Module>> MODULE_SET_SUPPLIER = () -> new TreeSet<>(REVISION_COMPARATOR);
+ protected static final TreeSet<Module> createModuleSet() {
+ return new TreeSet<>(REVISION_COMPARATOR);
+ }
/**
* Returns the ModuleIdentifier-to-YANG source mapping.
@Override
public Optional<String> getModuleSource(final ModuleIdentifier moduleIdentifier) {
- String maybeSource = getIdentifiersToSources().get(moduleIdentifier);
- return Optional.fromNullable(maybeSource);
+ return Optional.ofNullable(getIdentifiersToSources().get(moduleIdentifier));
}
-
}
*/
package org.opendaylight.yangtools.yang.model.util;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
*
* @param min length-restricting lower bound value. The value MUST NOT be negative.
* @param max length-restricting upper bound value. The value MUST NOT be negative.
- * @param description Description associated with constraint. {@link Optional#absent()} if description is undefined.
- * @param reference Reference associated with constraint. {@link Optional#absent()} if reference is undefined.
+ * @param description Description associated with constraint. {@link Optional#empty()} if description is undefined.
+ * @param reference Reference associated with constraint. {@link Optional#empty()} if reference is undefined.
* @return Instance of {@link LengthConstraint}
*/
public static LengthConstraint newLengthConstraint(final Number min, final Number max,
*
* @param min length-restricting lower bound value. The value MUST NOT be negative.
* @param max length-restricting upper bound value. The value MUST NOT be negative.
- * @param description Description associated with constraint. {@link Optional#absent()} if description is undefined.
- * @param reference Reference associated with constraint. {@link Optional#absent()} if reference is undefined.
+ * @param description Description associated with constraint. {@link Optional#empty()} if description is undefined.
+ * @param reference Reference associated with constraint. {@link Optional#empty()} if reference is undefined.
* @param errorAppTag error-app-tag associated with constraint.
* @param errorMessage error message associated with constraint.
* @return Instance of {@link LengthConstraint}
* @param <T> Type of constraint
* @param min value-restricting lower bound value. The value MUST NOT Be null.
* @param max value-restricting upper bound value. The value MUST NOT Be null.
- * @param description Description associated with constraint. {@link Optional#absent()} if description is undefined.
- * @param reference Reference associated with constraint. {@link Optional#absent()} if reference is undefined.
+ * @param description Description associated with constraint. {@link Optional#empty()} if description is undefined.
+ * @param reference Reference associated with constraint. {@link Optional#empty()} if reference is undefined.
* @return Instance of {@link RangeConstraint}
*/
public static <T extends Number> RangeConstraint newRangeConstraint(final T min, final T max,
* @param <T> Type of constraint
* @param min value-restricting lower bound value. The value MUST NOT Be null.
* @param max value-restricting upper bound value. The value MUST NOT Be null.
- * @param description Description associated with constraint. {@link Optional#absent()} if description is undefined.
- * @param reference Reference associated with constraint. {@link Optional#absent()} if reference is undefined.
+ * @param description Description associated with constraint. {@link Optional#empty()} if description is undefined.
+ * @param reference Reference associated with constraint. {@link Optional#empty()} if reference is undefined.
* @param errorAppTag error-app-tag associated with constraint.
* @param errorMessage error message associated with constraint.
* @return Instance of {@link RangeConstraint}
*/
package org.opendaylight.yangtools.yang.model.util;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
Preconditions.checkNotNull(additionalModuleIds, "Additional modules cannot be null.");
final Builder<Module> filteredModulesBuilder = new Builder<>();
- final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(), MODULE_SET_SUPPLIER);
- final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(new TreeMap<>(), MODULE_SET_SUPPLIER);
+ final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(),
+ AbstractSchemaContext::createModuleSet);
+ final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(new TreeMap<>(),
+ AbstractSchemaContext::createModuleSet);
ImmutableMap.Builder<ModuleIdentifier, String> identifiersToSourcesBuilder = ImmutableMap.builder();
*/
package org.opendaylight.yangtools.yang.model.util;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
final Optional<String> reference, final String errorAppTag, final String errorMessage) {
this.min = Preconditions.checkNotNull(min, "min must not be null.");
this.max = Preconditions.checkNotNull(max, "max must not be null");
- this.description = description.orNull();
- this.reference = reference.orNull();
+ this.description = description.orElse(null);
+ this.reference = reference.orElse(null);
this.errorAppTag = errorAppTag != null ? errorAppTag : "length-out-of-specified-bounds";
this.errorMessage = errorMessage != null ? errorMessage : "The argument is out of bounds <" + min + ", " + max
+ ">";
package org.opendaylight.yangtools.yang.model.util;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
private final ModifierKind modifier;
PatternConstraintImpl(final String regex, final Optional<String> description, final Optional<String> reference) {
- this(regex, description, reference, null, null, Optional.absent());
+ this(regex, description, reference, null, null, Optional.empty());
}
PatternConstraintImpl(final String regex, final Optional<String> description, final Optional<String> reference,
final String errorAppTag, final String errorMessage, final Optional<ModifierKind> modifier) {
this.regex = Preconditions.checkNotNull(regex, "regex must not be null.");
- this.description = description.orNull();
- this.reference = reference.orNull();
+ this.description = description.orElse(null);
+ this.reference = reference.orElse(null);
this.errorAppTag = errorAppTag != null ? errorAppTag : "invalid-regular-expression";
this.errorMessage = errorMessage != null ? errorMessage : String.format(
"Supplied value does not match the regular expression %s.", regex);
- this.modifier = modifier.orNull();
+ this.modifier = modifier.orElse(null);
}
@Override
*/
package org.opendaylight.yangtools.yang.model.util;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
final Optional<String> reference, final String errorAppTag, final String errorMessage) {
this.min = Preconditions.checkNotNull(min, "min must not be null.");
this.max = Preconditions.checkNotNull(max, "max must not be null.");
- this.description = description.orNull();
- this.reference = reference.orNull();
+ this.description = description.orElse(null);
+ this.reference = reference.orElse(null);
this.errorAppTag = errorAppTag != null ? errorAppTag : "range-out-of-specified-bounds";
this.errorMessage = errorMessage != null ? errorMessage : "The argument is out of bounds <" + min + ", " + max
+ ">";
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.Iterables;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
final TypeDefinition<?> targetTypeDefinition = typeDefinition(dataSchemaNode);
if (targetTypeDefinition instanceof LeafrefTypeDefinition) {
- return getBaseTypeForLeafRef(((LeafrefTypeDefinition) targetTypeDefinition), schemaContext, dataSchemaNode);
+ return getBaseTypeForLeafRef((LeafrefTypeDefinition) targetTypeDefinition, schemaContext, dataSchemaNode);
}
return targetTypeDefinition;
parentModule, strippedPathStatement);
final TypeDefinition<?> targetTypeDefinition = typeDefinition(dataSchemaNode);
if (targetTypeDefinition instanceof LeafrefTypeDefinition) {
- return getBaseTypeForLeafRef(((LeafrefTypeDefinition) targetTypeDefinition), schemaContext, dataSchemaNode);
+ return getBaseTypeForLeafRef((LeafrefTypeDefinition) targetTypeDefinition, schemaContext, dataSchemaNode);
}
return targetTypeDefinition;
*/
package org.opendaylight.yangtools.yang.model.util;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
public static Optional<SchemaNode> getOriginalIfPossible(final SchemaNode node) {
if (node instanceof DerivableSchemaNode) {
@SuppressWarnings("unchecked")
- final Optional<SchemaNode> ret = (Optional<SchemaNode>) (((DerivableSchemaNode) node).getOriginal());
+ final Optional<SchemaNode> ret = (Optional<SchemaNode>) ((DerivableSchemaNode) node).getOriginal();
return ret;
}
- return Optional.absent();
+ return Optional.empty();
}
public static SchemaNode getRootOriginalIfPossible(final SchemaNode data) {
- Optional<SchemaNode> previous = Optional.absent();
+ Optional<SchemaNode> previous = Optional.empty();
Optional<SchemaNode> next = getOriginalIfPossible(data);
while (next.isPresent()) {
previous = next;
next = getOriginalIfPossible(next.get());
}
- return previous.orNull();
+ return previous.orElse(null);
}
/**
*/
@Nullable public static ContainerSchemaNode getRpcDataSchema(@Nonnull final RpcDefinition rpc,
@Nonnull final QName qname) {
- Preconditions.checkNotNull(rpc, "Rpc Schema must not be null");
- Preconditions.checkNotNull(qname,"QName must not be null");
+ requireNonNull(rpc, "Rpc Schema must not be null");
+ requireNonNull(qname, "QName must not be null");
switch (qname.getLocalName()) {
case "input":
return rpc.getInput();
*
* Invest some quality time in building up lookup tables for both.
*/
- final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(), MODULE_SET_SUPPLIER);
- final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(new TreeMap<>(), MODULE_SET_SUPPLIER);
+ final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(),
+ AbstractSchemaContext::createModuleSet);
+ final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(new TreeMap<>(),
+ AbstractSchemaContext::createModuleSet);
final Set<ModuleIdentifier> modIdBuilder = new HashSet<>();
for (Module m : modules) {
nameMap.put(m.getName(), m);
*/
package org.opendaylight.yangtools.yang.model.util;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import java.util.List;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
}
private static Number resolve(final Number number) {
- Preconditions.checkArgument(!(number instanceof UnresolvedNumber));
+ checkArgument(!(number instanceof UnresolvedNumber));
return number;
}
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
AbstractRangeRestrictedBaseType(final QName qname, final Number minValue, final Number maxValue) {
super(qname);
this.rangeConstraints = ImmutableList.of(BaseConstraints.newRangeConstraint(
- minValue, maxValue, Optional.absent(), Optional.absent()));
+ minValue, maxValue, Optional.empty(), Optional.empty()));
}
AbstractRangeRestrictedBaseType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes,
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import java.math.BigDecimal;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
private static List<RangeConstraint> createRangeConstraint(final String min, final String max) {
return ImmutableList.of(BaseConstraints.newRangeConstraint(new BigDecimal(min), new BigDecimal(max),
- Optional.absent(), Optional.of("https://tools.ietf.org/html/rfc6020#section-9.3.4")));
+ Optional.empty(), Optional.of("https://tools.ietf.org/html/rfc6020#section-9.3.4")));
}
static List<RangeConstraint> constraintsForDigits(final int fractionDigits) {
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import java.util.List;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.util.BaseConstraints;
}
static final List<LengthConstraint> INTEGER_SIZE_CONSTRAINTS = ImmutableList.of(
- BaseConstraints.newLengthConstraint(0, Integer.MAX_VALUE, Optional.absent(), Optional.absent()));
+ BaseConstraints.newLengthConstraint(0, Integer.MAX_VALUE, Optional.empty(), Optional.empty()));
}
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.function.Function;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
final Number rMin = min instanceof UnresolvedNumber
? ((UnresolvedNumber)min).resolveLength(baseLengthConstraints) : min;
- builder.add(BaseConstraints.newLengthConstraint(rMin, rMax, Optional.fromNullable(c.getDescription()),
- Optional.fromNullable(c.getReference()), c.getErrorAppTag(), c.getErrorMessage()));
+ builder.add(BaseConstraints.newLengthConstraint(rMin, rMax, Optional.ofNullable(c.getDescription()),
+ Optional.ofNullable(c.getReference()), c.getErrorAppTag(), c.getErrorMessage()));
} else {
builder.add(c);
}
throw new IllegalArgumentException(String.format("Constraint %s does not fit into range of %s",
c, clazz.getSimpleName()), e);
}
- builder.add(BaseConstraints.newLengthConstraint(min, max, Optional.fromNullable(c.getDescription()),
- Optional.fromNullable(c.getReference()), c.getErrorAppTag(), c.getErrorMessage()));
+ builder.add(BaseConstraints.newLengthConstraint(min, max, Optional.ofNullable(c.getDescription()),
+ Optional.ofNullable(c.getReference()), c.getErrorAppTag(), c.getErrorMessage()));
} else {
builder.add(c);
}
*/
package org.opendaylight.yangtools.yang.model.util.type;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.function.Function;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
final Number rMin = min instanceof UnresolvedNumber
? ((UnresolvedNumber)min).resolveRange(baseRangeConstraints) : min;
- builder.add(BaseConstraints.newRangeConstraint(rMin, rMax, Optional.fromNullable(c.getDescription()),
- Optional.fromNullable(c.getReference()), c.getErrorAppTag(), c.getErrorMessage()));
+ builder.add(BaseConstraints.newRangeConstraint(rMin, rMax, Optional.ofNullable(c.getDescription()),
+ Optional.ofNullable(c.getReference()), c.getErrorAppTag(), c.getErrorMessage()));
} else {
builder.add(c);
}
throw new IllegalArgumentException(String.format("Constraint %s does not fit into range of %s",
c, clazz.getSimpleName()), e);
}
- builder.add(BaseConstraints.newRangeConstraint(min, max, Optional.fromNullable(c.getDescription()),
- Optional.fromNullable(c.getReference()), c.getErrorAppTag(), c.getErrorMessage()));
+ builder.add(BaseConstraints.newRangeConstraint(min, max, Optional.ofNullable(c.getDescription()),
+ Optional.ofNullable(c.getReference()), c.getErrorAppTag(), c.getErrorMessage()));
} else {
builder.add(c);
}
import static org.mockito.Mockito.verify;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Optional;
import com.google.common.collect.Collections2;
import com.google.common.io.Files;
import com.google.common.util.concurrent.CheckedFuture;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Before;
private final String content;
protected TestingYangSource(final String name, final String revision, final String content) {
- super(RevisionSourceIdentifier.create(name, Optional.fromNullable(revision)));
+ super(RevisionSourceIdentifier.create(name, Optional.ofNullable(revision)));
this.content = content;
}
import static org.mockito.Mockito.doReturn;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.junit.Assert;
private final String content;
protected TestingYangSource(final String name, final String revision, final String content) {
- super(RevisionSourceIdentifier.create(name, Optional.fromNullable(revision)));
+ super(RevisionSourceIdentifier.create(name, Optional.ofNullable(revision)));
this.content = content;
}
import static org.junit.Assert.assertEquals;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.collect.Sets;
+import com.google.common.collect.ImmutableSet;
import java.util.Collections;
import java.util.NoSuchElementException;
import java.util.Set;
final ChoiceSchemaNode mockedChoice = mock(ChoiceSchemaNode.class);
final ChoiceCaseNode mockedCase1 = mock(ChoiceCaseNode.class);
final ChoiceCaseNode mockedCase2 = mock(ChoiceCaseNode.class);
- final Set<ChoiceCaseNode> cases = Sets.newHashSet(mockedCase1, mockedCase2);
+ final Set<ChoiceCaseNode> cases = ImmutableSet.of(mockedCase1, mockedCase2);
doReturn(cases).when(mockedChoice).getCases();
- final Set<DataSchemaNode> childNodes = Sets.newHashSet(mockedAugmentingContainer, mockedContainer, mockedList,
+ final Set<DataSchemaNode> childNodes = ImmutableSet.of(mockedAugmentingContainer, mockedContainer, mockedList,
mockedChoice);
doReturn(childNodes).when(mockedModule).getChildNodes();
final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
final ContainerSchemaNode mockedContainerInNotification = mock(ContainerSchemaNode.class);
- final Set<DataSchemaNode> notificationChildNodes = Sets.newHashSet(mockedContainerInNotification);
+ final Set<DataSchemaNode> notificationChildNodes = ImmutableSet.of(mockedContainerInNotification);
doReturn(notificationChildNodes).when(mockedNotification).getChildNodes();
- final Set<NotificationDefinition> notifications = Sets.newHashSet(mockedNotification);
+ final Set<NotificationDefinition> notifications = ImmutableSet.of(mockedNotification);
doReturn(notifications).when(mockedModule).getNotifications();
final RpcDefinition mockedRpc = mock(RpcDefinition.class);
final ContainerSchemaNode mockedContainerInRpcInput = mock(ContainerSchemaNode.class);
final ListSchemaNode mockedListInRpcInputContainer = mock(ListSchemaNode.class);
- final Set<DataSchemaNode> rpcInputChildNodes = Sets.newHashSet(mockedListInRpcInputContainer);
+ final Set<DataSchemaNode> rpcInputChildNodes = ImmutableSet.of(mockedListInRpcInputContainer);
doReturn(rpcInputChildNodes).when(mockedContainerInRpcInput).getChildNodes();
doReturn(mockedContainerInRpcInput).when(mockedRpc).getInput();
- final Set<RpcDefinition> rpcs = Sets.newHashSet(mockedRpc);
+ final Set<RpcDefinition> rpcs = ImmutableSet.of(mockedRpc);
doReturn(rpcs).when(mockedModule).getRpcs();
final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
- final Set<GroupingDefinition> groupings = Sets.newHashSet(mockedGrouping);
+ final Set<GroupingDefinition> groupings = ImmutableSet.of(mockedGrouping);
doReturn(groupings).when(mockedModule).getGroupings();
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Test;
public class PatternConstraintImplTest {
import static org.mockito.Mockito.mock;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
new HashSet<>(), moduleConfig);
final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
- final List<ExtensionDefinition> extensions = Lists.newArrayList(mockedExtension);
+ final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
new HashSet<>(), moduleConfig);
final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
- final List<UnknownSchemaNode> unknownSchemaNodes = Lists.newArrayList(mockedUnknownSchemaNode);
+ final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.doReturn;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
-import com.google.common.base.Optional;
import java.util.ArrayList;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.common.QName;
private static final RevisionAwareXPath REVISION_AWARE_XPATH = new RevisionAwareXPathImpl("/test", true);
private static final Bit BIT_A = BitBuilder.create(SCHEMA_PATH, 55L).setDescription("description")
.setReference("reference").build();
- private static final Optional<String> ABSENT = Optional.absent();
+ private static final Optional<String> ABSENT = Optional.empty();
@Test
public void binaryTypeTest() {
@Test
public void exceptionTest() {
- final Optional<String> absent = Optional.absent();
final UnresolvedNumber min = UnresolvedNumber.min();
final UnresolvedNumber max = UnresolvedNumber.max();
- final LengthConstraint lengthConstraint = BaseConstraints.newLengthConstraint(min, max, absent, absent);
- final RangeConstraint rangeConstraint = BaseConstraints.newRangeConstraint(min, max, absent, absent);
+ final LengthConstraint lengthConstraint = BaseConstraints.newLengthConstraint(min, max, ABSENT, ABSENT);
+ final RangeConstraint rangeConstraint = BaseConstraints.newRangeConstraint(min, max, ABSENT, ABSENT);
final EnumPair enumPair = EnumPairBuilder.create("enum1", 1).setDescription("description")
.setReference("reference").setUnknownSchemaNodes(mock(UnknownSchemaNode.class)).build();
*/
package org.opendaylight.yangtools.yang.parser.impl.util;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.Date;
import java.util.HashSet;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import org.antlr.v4.runtime.ParserRuleContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangStatementParser.StatementContext;
YangModelDependencyInfo(final String name, final String formattedRevision,
final ImmutableSet<ModuleImport> imports,
final ImmutableSet<ModuleImport> includes) {
- this(name, formattedRevision, imports, includes, Optional.absent());
+ this(name, formattedRevision, imports, includes, Optional.empty());
}
YangModelDependencyInfo(final String name, final String formattedRevision,
final YangStatementStreamSource source = YangStatementStreamSource.create(
YangTextSchemaSource.forResource(refClass, resourceName));
final ParserRuleContext ast = source.getYangAST();
- Preconditions.checkArgument(ast instanceof StatementContext);
+ checkArgument(ast instanceof StatementContext);
return parseAST((StatementContext) ast, source.getIdentifier().toYangFilename());
}
private static YangModelDependencyInfo parseModuleContext(final StatementContext module, final String sourceName) {
final String name = Utils.stringFromStringContext(module.argument(), getReference(sourceName, module));
final String latestRevision = getLatestRevision(module, sourceName);
- final Optional<SemVer> semVer = Optional.fromNullable(findSemanticVersion(module, sourceName));
+ final Optional<SemVer> semVer = Optional.ofNullable(findSemanticVersion(module, sourceName));
final ImmutableSet<ModuleImport> imports = parseImports(module, sourceName);
final ImmutableSet<ModuleImport> includes = parseIncludes(module, sourceName);
final String importedModuleName = Utils.stringFromStringContext(subStatementContext.argument(),
getReference(sourceName, subStatementContext));
final Date revisionDate = revisionDateStr == null ? null : QName.parseRevision(revisionDateStr);
- final Optional<SemVer> importSemVer = Optional.fromNullable(findSemanticVersion(subStatementContext,
+ final Optional<SemVer> importSemVer = Optional.ofNullable(findSemanticVersion(subStatementContext,
sourceName));
result.add(new ModuleImportImpl(importedModuleName, revisionDate, importSemVer));
}
@Override
public String toString() {
- return "Module [name=" + getName() + ", revision=" + getRevision() + ", semanticVersion="
- + getSemanticVersion().or(Module.DEFAULT_SEMANTIC_VERSION) + ", dependencies=" + getDependencies()
- + "]";
+ return "Module [name=" + getName() + ", revision=" + getRevision()
+ + ", semanticVersion=" + getSemanticVersion().orElse(Module.DEFAULT_SEMANTIC_VERSION)
+ + ", dependencies=" + getDependencies()
+ + "]";
}
}
private final String name;
ModuleImportImpl(final String moduleName, final Date revision) {
- this(moduleName, revision, Optional.absent());
+ this(moduleName, revision, Optional.empty());
}
ModuleImportImpl(final String moduleName, final Date revision, final Optional<SemVer> semVer) {
- this.name = Preconditions.checkNotNull(moduleName, "Module name must not be null.");
+ this.name = requireNonNull(moduleName, "Module name must not be null.");
this.revision = revision;
- this.semVer = semVer.or(Module.DEFAULT_SEMANTIC_VERSION);
+ this.semVer = semVer.orElse(Module.DEFAULT_SEMANTIC_VERSION);
}
@Override
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMultimap;
-import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
+import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
protected DependencyResolver(final Map<SourceIdentifier, YangModelDependencyInfo> depInfo) {
final Collection<SourceIdentifier> resolved = new ArrayList<>(depInfo.size());
final Collection<SourceIdentifier> pending = new ArrayList<>(depInfo.keySet());
- final Map<SourceIdentifier, BelongsToDependency> submodules = Maps.newHashMap();
+ final Map<SourceIdentifier, BelongsToDependency> submodules = new HashMap<>();
boolean progress;
do {
*/
package org.opendaylight.yangtools.yang.parser.repo;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@Override
protected boolean isKnown(final Collection<SourceIdentifier> haystack, final ModuleImport mi) {
final String rev = mi.getRevision() != null ? QName.formattedRevision(mi.getRevision()) : null;
- final SourceIdentifier msi = SourceIdentifier.create(mi.getModuleName(), Optional.fromNullable(rev));
+ final SourceIdentifier msi = SourceIdentifier.create(mi.getModuleName(), Optional.ofNullable(rev));
// Quick lookup
if (haystack.contains(msi)) {
*/
package org.opendaylight.yangtools.yang.parser.repo;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
@Override
protected boolean isKnown(final Collection<SourceIdentifier> haystack, final ModuleImport mi) {
final String rev = mi.getRevision() != null ? QName.formattedRevision(mi.getRevision()) : null;
- final SemVerSourceIdentifier msi = SemVerSourceIdentifier.create(mi.getModuleName(), Optional.fromNullable(rev),
+ final SemVerSourceIdentifier msi = SemVerSourceIdentifier.create(mi.getModuleName(), Optional.ofNullable(rev),
mi.getSemanticVersion());
// Quick lookup
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ImmutableSet;
import java.io.InputStream;
import java.net.URL;
import java.util.Collection;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.TimeUnit;
private final Collection<SourceIdentifier> requiredSources = new ConcurrentLinkedDeque<>();
private final Multimap<SourceIdentifier, YangTextSchemaSource> texts = ArrayListMultimap.create();
private final AtomicReference<Optional<SchemaContext>> currentSchemaContext =
- new AtomicReference<>(Optional.absent());
+ new AtomicReference<>(Optional.empty());
private final InMemorySchemaSourceCache<ASTSchemaSource> cache;
private final SchemaListenerRegistration transReg;
private final SchemaSourceRegistry registry;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
import com.google.common.collect.Table;
import com.google.common.collect.TreeBasedTable;
import java.util.ArrayList;
@SuppressWarnings("checkstyle:illegalCatch")
private void completePhaseActions() throws ReactorException {
Preconditions.checkState(currentPhase != null);
- final List<SourceSpecificContext> sourcesToProgress = Lists.newArrayList(sources);
+ final List<SourceSpecificContext> sourcesToProgress = new ArrayList<>(sources);
if (!libSources.isEmpty()) {
Preconditions.checkState(currentPhase == ModelProcessingPhase.SOURCE_PRE_LINKAGE,
"Yang library sources should be empty after ModelProcessingPhase.SOURCE_PRE_LINKAGE, "
*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
RootStatementContext(final SourceSpecificContext sourceContext, final StatementDefinitionContext<A, D, E> def,
final StatementSourceReference ref, final String rawArgument) {
super(def, ref, rawArgument);
- this.sourceContext = Preconditions.checkNotNull(sourceContext);
+ this.sourceContext = requireNonNull(sourceContext);
this.argument = def.parseArgumentValue(this, rawStatementArgument());
}
if (includedContexts.isEmpty()) {
includedContexts = new ArrayList<>(1);
}
- Verify.verify(value instanceof RootStatementContext);
+ verify(value instanceof RootStatementContext);
includedContexts.add((RootStatementContext<?, ?, ?>) value);
}
return super.putToLocalStorage(type, key, value);
@Override
public void setRootVersion(final YangVersion version) {
- Preconditions.checkArgument(sourceContext.getSupportedVersions().contains(version),
+ checkArgument(sourceContext.getSupportedVersions().contains(version),
"Unsupported yang version %s in %s", version, getStatementSourceReference());
- Preconditions.checkState(this.version == null, "Version of root %s has been already set to %s", argument,
+ checkState(this.version == null, "Version of root %s has been already set to %s", argument,
this.version);
- this.version = Preconditions.checkNotNull(version);
+ this.version = requireNonNull(version);
}
@Override
@Override
public void addRequiredModule(final ModuleIdentifier dependency) {
- Preconditions.checkState(sourceContext.getInProgressPhase() == ModelProcessingPhase.SOURCE_PRE_LINKAGE,
+ checkState(sourceContext.getInProgressPhase() == ModelProcessingPhase.SOURCE_PRE_LINKAGE,
"Add required module is allowed only in ModelProcessingPhase.SOURCE_PRE_LINKAGE phase");
if (requiredModules.isEmpty()) {
requiredModules = new HashSet<>();
@Override
public void setRootIdentifier(final ModuleIdentifier identifier) {
- Preconditions.checkNotNull(identifier);
- this.identifier = identifier;
+ this.identifier = requireNonNull(identifier);
}
ModuleIdentifier getRootIdentifier() {
*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
+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.AbstractIterator;
import com.google.common.collect.ImmutableList;
Regular(final int index, final StatementContextBase<?, ?, ?> object) {
elements = new StatementContextBase<?, ?, ?>[index + 1];
- elements[index] = Preconditions.checkNotNull(object);
+ elements[index] = requireNonNull(object);
}
Regular(final StatementContextBase<?, ?, ?> object0, final int index,
final StatementContextBase<?, ?, ?> object) {
elements = new StatementContextBase<?, ?, ?>[index + 1];
- elements[0] = Preconditions.checkNotNull(object0);
- elements[index] = Preconditions.checkNotNull(object);
+ elements[0] = requireNonNull(object0);
+ elements[index] = requireNonNull(object);
}
@Override
@Override
StatementMap put(final int index, final StatementContextBase<?, ?, ?> object) {
if (index < elements.length) {
- Preconditions.checkArgument(elements[index] == null);
+ checkArgument(elements[index] == null);
} else {
elements = Arrays.copyOf(elements, index + 1);
}
- elements[index] = Preconditions.checkNotNull(object);
+ elements[index] = requireNonNull(object);
return this;
}
private final StatementContextBase<?, ?, ?> object;
Singleton(final StatementContextBase<?, ?, ?> object) {
- this.object = Preconditions.checkNotNull(object);
+ this.object = requireNonNull(object);
}
@Override
@Override
StatementMap put(final int index, final StatementContextBase<?, ?, ?> object) {
- Preconditions.checkArgument(index != 0);
+ checkArgument(index != 0);
return new Regular(this.object, index, object);
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
return Optional.of((ContainerSchemaNode) anyXmlSchemaNode);
}
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
private final String argument;
private BuiltinTypeStatement(final String argument) {
- this.argument = Preconditions.checkNotNull(argument);
+ this.argument = requireNonNull(argument);
}
static TypeStatement maybeReplace(final TypeStatementImpl orig) {
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Set;
import java.util.function.Predicate;
import org.antlr.v4.runtime.CharStreams;
private final StmtContext<?, ?, ?> stmtCtx;
IfFeaturePredicateVisitor(final StmtContext<?, ?, ?> ctx) {
- this.stmtCtx = Preconditions.checkNotNull(ctx);
+ this.stmtCtx = requireNonNull(ctx);
}
@Override
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+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;
import org.opendaylight.yangtools.yang.common.QName;
private final boolean yinElement;
ModelDefinedStatementDefinition(final QName statementName, final QName argumentName, final boolean yinElement) {
- this.statementName = Preconditions.checkNotNull(statementName);
+ this.statementName = requireNonNull(statementName);
this.argumentName = argumentName;
this.yinElement = yinElement;
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import javax.annotation.Nonnull;
return null;
}
- return new PatternConstraintEffectiveImpl(pattern, value, Optional.absent(), Optional.absent());
+ return new PatternConstraintEffectiveImpl(pattern, value, Optional.empty(), Optional.empty());
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.BiMap;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.Iterators;
}
private StmtNamespaceContext(final StmtContext<?, ?, ?> ctx, final BiMap<String, String> uriToPrefix) {
- this.ctx = Preconditions.checkNotNull(ctx);
- this.uriToPrefix = ImmutableBiMap.copyOf(Preconditions.checkNotNull(uriToPrefix));
+ this.ctx = requireNonNull(ctx);
+ this.uriToPrefix = ImmutableBiMap.copyOf(requireNonNull(uriToPrefix));
}
public static NamespaceContext create(final StmtContext<?, ?, ?> ctx) {
private String localNamespaceURI() {
if (localNamespaceURI == null) {
- localNamespaceURI = Verify.verifyNotNull(
- ctx.getPublicDefinition().getStatementName().getNamespace().toString(),
+ localNamespaceURI = verifyNotNull(ctx.getPublicDefinition().getStatementName().getNamespace().toString(),
"Local namespace URI not found in %s", ctx);
}
return localNamespaceURI;
@Override
public String getNamespaceURI(final String prefix) {
// API-mandated by NamespaceContext
- Preconditions.checkArgument(prefix != null);
+ checkArgument(prefix != null);
final String uri = uriToPrefix.inverse().get(prefix);
if (uri != null) {
@Override
public String getPrefix(final String namespaceURI) {
// API-mandated by NamespaceContext
- Preconditions.checkArgument(namespaceURI != null);
+ checkArgument(namespaceURI != null);
final String prefix = uriToPrefix.get(namespaceURI);
if (prefix != null) {
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+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;
import org.opendaylight.yangtools.yang.common.QName;
final Class<? extends DeclaredStatement<?>> declared,
final Class<? extends EffectiveStatement<?, ?>> effective, final String nameStr, final String argumentStr,
final boolean yinElement) {
- type = Preconditions.checkNotNull(declared);
- effectiveType = Preconditions.checkNotNull(effective);
+ type = requireNonNull(declared);
+ effectiveType = requireNonNull(effective);
name = createQName(namespace, revision, nameStr);
argument = createQName(namespace, revision, argumentStr);
this.yinElement = yinElement;
SupportedExtensionsMapping(final String namespace, final Class<? extends DeclaredStatement<?>> declared,
final Class<? extends EffectiveStatement<?, ?>> effective, final String nameStr, final String argumentStr,
final boolean yinElement) {
- type = Preconditions.checkNotNull(declared);
- effectiveType = Preconditions.checkNotNull(effective);
+ type = requireNonNull(declared);
+ effectiveType = requireNonNull(effective);
name = createQName(namespace, nameStr);
argument = createQName(namespace, argumentStr);
this.yinElement = yinElement;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.YangVersion;
public static List<RangeConstraint> parseRangeListFromString(final StmtContext<?, ?, ?> ctx,
final String rangeArgument) {
- final Optional<String> description = Optional.absent();
- final Optional<String> reference = Optional.absent();
+ final Optional<String> description = Optional.empty();
+ final Optional<String> reference = Optional.empty();
final List<RangeConstraint> rangeConstraints = new ArrayList<>();
public static List<LengthConstraint> parseLengthListFromString(final StmtContext<?, ?, ?> ctx,
final String lengthArgument) {
- final Optional<String> description = Optional.absent();
- final Optional<String> reference = Optional.absent();
+ final Optional<String> description = Optional.empty();
+ final Optional<String> reference = Optional.empty();
final List<LengthConstraint> lengthConstraints = new ArrayList<>();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
@Override
public Optional<AnyXmlSchemaNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.Date;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QNameModule;
@Override
public Optional<AugmentationSchema> getOriginalDefinition() {
- return Optional.fromNullable(this.copyOf);
+ return Optional.ofNullable(this.copyOf);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
@Override
public Optional<ChoiceCaseNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
private final boolean augmenting;
CaseShorthandImpl(final DataSchemaNode caseShorthandNode) {
- this.caseShorthandNode = Preconditions.checkNotNull(caseShorthandNode);
- this.path = Preconditions.checkNotNull(caseShorthandNode.getPath().getParent());
+ this.caseShorthandNode = requireNonNull(caseShorthandNode);
+ this.path = requireNonNull(caseShorthandNode.getPath().getParent());
this.original = getOriginalIfPresent(caseShorthandNode);
// We need to cache this, as it will be reset
@Override
public Optional<? extends SchemaNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import java.util.LinkedHashSet;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
@Override
public Optional<ChoiceSchemaNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
@Override
public Optional<ContainerSchemaNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableSet;
import java.util.Set;
import org.opendaylight.yangtools.yang.data.util.ConstraintDefinitions;
this.minElements = minElements;
this.maxElements = maxElements;
this.whenCondition = whenCondition;
- this.mustConstraints = Preconditions.checkNotNull(mustConstraints);
+ this.mustConstraints = requireNonNull(mustConstraints);
}
static ConstraintDefinition forParent(final EffectiveStatementBase<?, ?> parent) {
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
-import com.google.common.base.Predicates;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
+import java.util.function.Predicate;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
}
protected final <S extends EffectiveStatement<?, ?>> S firstEffective(final Class<S> type) {
- final Optional<? extends EffectiveStatement<?, ?>> possible = Iterables.tryFind(substatements,
- Predicates.instanceOf(type));
- return possible.isPresent() ? type.cast(possible.get()) : null;
+ return substatements.stream().filter(type::isInstance).findFirst().map(type::cast).orElse(null);
}
protected final <S extends SchemaNode> S firstSchemaNode(final Class<S> type) {
- final Optional<? extends EffectiveStatement<?, ?>> possible = Iterables.tryFind(substatements,
- Predicates.instanceOf(type));
- return possible.isPresent() ? type.cast(possible.get()) : null;
+ return substatements.stream().filter(type::isInstance).findFirst().map(type::cast).orElse(null);
}
@SuppressWarnings("unchecked")
protected final <T> Collection<T> allSubstatementsOfType(final Class<T> type) {
- return Collection.class.cast(Collections2.filter(substatements, Predicates.instanceOf(type)));
+ return Collection.class.cast(Collections2.filter(substatements, type::isInstance));
}
protected final <T> T firstSubstatementOfType(final Class<T> type) {
- final Optional<? extends EffectiveStatement<?, ?>> possible = Iterables.tryFind(substatements,
- Predicates.instanceOf(type));
- return possible.isPresent() ? type.cast(possible.get()) : null;
+ return substatements.stream().filter(type::isInstance).findFirst().map(type::cast).orElse(null);
}
protected final <R> R firstSubstatementOfType(final Class<?> type, final Class<R> returnType) {
- final Optional<? extends EffectiveStatement<?, ?>> possible = Iterables.tryFind(substatements,
- Predicates.and(Predicates.instanceOf(type), Predicates.instanceOf(returnType)));
- return possible.isPresent() ? returnType.cast(possible.get()) : null;
+ return substatements.stream()
+ .filter(((Predicate<Object>)type::isInstance).and(returnType::isInstance))
+ .findFirst().map(returnType::cast).orElse(null);
}
protected final EffectiveStatement<?, ?> firstEffectiveSubstatementOfType(final Class<?> type) {
- return Iterables.tryFind(substatements, Predicates.instanceOf(type)).orNull();
+ return substatements.stream().filter(type::isInstance).findFirst().orElse(null);
}
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
@Override
public Optional<LeafSchemaNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
@Override
public Optional<LeafListSchemaNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
@Override
public Optional<ListSchemaNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
@Nonnull
@Override
public Optional<RevisionAwareXPath> getWhenCondition() {
- return Optional.fromNullable(whenCondition);
+ return Optional.ofNullable(whenCondition);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Objects;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
public YangModeledAnyXmlEffectiveStatementImpl(final StmtContext<QName, AnyxmlStatement,
EffectiveStatement<QName, AnyxmlStatement>> ctx, final ContainerSchemaNode contentSchema) {
super(ctx);
- schemaOfAnyXmlData = Preconditions.checkNotNull(contentSchema);
+ schemaOfAnyXmlData = requireNonNull(contentSchema);
}
@Nonnull
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.Map;
private final TypeDefinition<?> typedef;
BuiltinEffectiveStatement(final TypeDefinition<?> typedef) {
- this.typedef = Preconditions.checkNotNull(typedef);
+ this.typedef = requireNonNull(typedef);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
public class LengthConstraintEffectiveImpl implements LengthConstraint {
public LengthConstraintEffectiveImpl(final Number min, final Number max, final Optional<String> description,
final Optional<String> reference) {
- this(min, max, description.orNull(), reference.orNull(), "length-out-of-specified-bounds",
+ this(min, max, description.orElse(null), reference.orElse(null), "length-out-of-specified-bounds",
"The argument is out of bounds <" + min + ", " + max + ">");
}
public LengthConstraintEffectiveImpl(final Number min, final Number max, final String description,
final String reference, final String errorAppTag, final String errorMessage) {
- this.min = Preconditions.checkNotNull(min, "min must not be null.");
- this.max = Preconditions.checkNotNull(max, "max must not be null");
+ this.min = requireNonNull(min, "min must not be null");
+ this.max = requireNonNull(max, "max must not be null");
this.description = description;
this.reference = reference;
this.errorAppTag = errorAppTag != null ? errorAppTag : "length-out-of-specified-bounds";
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
public PatternConstraintEffectiveImpl(final String regex, final String rawRegex,
final Optional<String> description, final Optional<String> reference) {
- this(regex, rawRegex, description.orNull(), reference.orNull(), null, null, null);
+ this(regex, rawRegex, description.orElse(null), reference.orElse(null), null, null, null);
}
public PatternConstraintEffectiveImpl(final String regex, final String rawRegex, final String description,
final String reference, final String errorAppTag, final String errorMessage, final ModifierKind modifier) {
- this.regEx = Preconditions.checkNotNull(regex, "regex must not be null.");
- this.rawRegEx = Preconditions.checkNotNull(rawRegex, "raw regex must not be null.");
+ this.regEx = requireNonNull(regex, "regex must not be null");
+ this.rawRegEx = requireNonNull(rawRegex, "raw regex must not be null");
this.description = description;
this.reference = reference;
this.errorAppTag = errorAppTag != null ? errorAppTag : "invalid-regular-expression";
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
public class RangeConstraintEffectiveImpl implements RangeConstraint {
public RangeConstraintEffectiveImpl(final Number min, final Number max, final Optional<String> description,
final Optional<String> reference) {
- this(min, max, description.orNull(), reference.orNull(), "range-out-of-specified-bounds",
+ this(min, max, description.orElse(null), reference.orElse(null), "range-out-of-specified-bounds",
"The argument is out of bounds <" + min + ", " + max + ">");
}
public RangeConstraintEffectiveImpl(final Number min, final Number max, final String description,
final String reference, final String errorAppTag, final String errorMessage) {
- this.min = Preconditions.checkNotNull(min, "min must not be null.");
- this.max = Preconditions.checkNotNull(max, "max must not be null.");
+ this.min = requireNonNull(min, "min must not be null");
+ this.max = requireNonNull(max, "max must not be null");
this.description = description;
this.reference = reference;
this.errorAppTag = errorAppTag != null ? errorAppTag : "range-out-of-specified-bounds";
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
@Override
public Optional<AnyDataSchemaNode> getOriginal() {
- return Optional.fromNullable(original);
+ return Optional.ofNullable(original);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.util;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.model.api.Module.DEFAULT_SEMANTIC_VERSION;
import com.google.common.annotations.Beta;
-import com.google.common.base.Function;
-import com.google.common.base.Preconditions;
import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
*/
@Beta
public final class ASTSchemaSource implements SchemaSourceRepresentation {
- @Deprecated
- public static final Function<ASTSchemaSource, SourceIdentifier> GET_IDENTIFIER =
- ASTSchemaSource::getIdentifier;
- @Deprecated
- public static final Function<ASTSchemaSource, SourceIdentifier> GET_SEMVER_IDENTIFIER =
- ASTSchemaSource::getSemVerIdentifier;
- @Deprecated
- public static final Function<ASTSchemaSource, YangModelDependencyInfo> GET_DEPINFO =
- ASTSchemaSource::getDependencyInformation;
- @Deprecated
- public static final Function<ASTSchemaSource, ParserRuleContext> GET_AST = ASTSchemaSource::getAST;
-
private final YangModelDependencyInfo depInfo;
private final SemVerSourceIdentifier semVerId;
private final ParserRuleContext tree;
private ASTSchemaSource(@Nonnull final SourceIdentifier id, @Nonnull final SemVerSourceIdentifier semVerId,
@Nonnull final ParserRuleContext tree, @Nonnull final YangModelDependencyInfo depInfo,
@Nullable final String symbolicName) {
- this.depInfo = Preconditions.checkNotNull(depInfo);
- this.tree = Preconditions.checkNotNull(tree);
- this.id = Preconditions.checkNotNull(id);
- this.semVerId = Preconditions.checkNotNull(semVerId);
+ this.depInfo = requireNonNull(depInfo);
+ this.tree = requireNonNull(tree);
+ this.id = requireNonNull(id);
+ this.semVerId = requireNonNull(semVerId);
this.symbolicName = symbolicName;
}
private static SemVerSourceIdentifier getSemVerSourceId(final YangModelDependencyInfo depInfo) {
return depInfo.getFormattedRevision() == null
? SemVerSourceIdentifier.create(depInfo.getName(),
- depInfo.getSemanticVersion().or(DEFAULT_SEMANTIC_VERSION))
+ depInfo.getSemanticVersion().orElse(DEFAULT_SEMANTIC_VERSION))
: SemVerSourceIdentifier.create(depInfo.getName(), depInfo.getFormattedRevision(),
- depInfo.getSemanticVersion().or(DEFAULT_SEMANTIC_VERSION));
+ depInfo.getSemanticVersion().orElse(DEFAULT_SEMANTIC_VERSION));
}
}
import static org.junit.Assert.assertEquals;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
private static SourceIdentifier getSourceId(final YangModelDependencyInfo depInfo) {
final String name = depInfo.getName();
- return RevisionSourceIdentifier.create(name, Optional.fromNullable(depInfo.getFormattedRevision()));
+ return RevisionSourceIdentifier.create(name, Optional.ofNullable(depInfo.getFormattedRevision()));
}
}
import static org.junit.Assert.fail;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
import org.junit.Test;
.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
final CheckedFuture<SchemaContext, SchemaResolutionException> schemaContextFuture = fact
- .createSchemaContext(Lists.newArrayList(foo.getId(), bar1.getId(), bar2.getId()));
+ .createSchemaContext(ImmutableList.of(foo.getId(), bar1.getId(), bar2.getId()));
assertTrue(schemaContextFuture.isDone());
try {
import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ListenableFuture;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
assertSchemaContext(inetAndTopologySchemaContextFuture.get(), 3);
final ListenableFuture<SchemaContext> barSchemaContextFuture = fact
- .createSchemaContext(Lists.newArrayList(bar.getId(), semVer.getId()), StatementParserMode.SEMVER_MODE);
+ .createSchemaContext(ImmutableList.of(bar.getId(), semVer.getId()), StatementParserMode.SEMVER_MODE);
assertTrue(barSchemaContextFuture.isDone());
assertSchemaContext(barSchemaContextFuture.get(), 2);
}
.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
final ListenableFuture<SchemaContext> inetAndTopologySchemaContextFuture =
- fact.createSchemaContext(Lists.newArrayList(bar.getId(), foo.getId(), semVer.getId()));
+ fact.createSchemaContext(ImmutableList.of(bar.getId(), foo.getId(), semVer.getId()));
assertTrue(inetAndTopologySchemaContextFuture.isDone());
assertSchemaContext(inetAndTopologySchemaContextFuture.get(), 3);
final ListenableFuture<SchemaContext> barSchemaContextFuture =
- fact.createSchemaContext(Lists.newArrayList(bar.getId(), semVer.getId()));
+ fact.createSchemaContext(ImmutableList.of(bar.getId(), semVer.getId()));
assertTrue(barSchemaContextFuture.isDone());
assertSchemaContext(barSchemaContextFuture.get(), 2);
}
package org.opendaylight.yangtools.yang.parser.repo;
-import com.google.common.base.Function;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.SettableFuture;
-import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@Override
public CheckedFuture<T, SchemaSourceException> getSource(final SourceIdentifier sourceIdentifier) {
- return Futures.makeChecked(future, new Function<Exception, SchemaSourceException>() {
- @Nullable
- @Override
- public SchemaSourceException apply(@Nullable final Exception input) {
- return new SchemaSourceException("Failed", input);
- }
- });
+ return Futures.makeChecked(future, input -> new SchemaSourceException("Failed", input));
}
public T getSchemaSourceRepresentation() {
import static org.mockito.Mockito.verify;
import static org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter.ALWAYS_ACCEPT;
-import com.google.common.base.Function;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
-import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
import com.google.common.io.Files;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
import org.junit.Test;
assertEquals(4, listener.registeredSources.size());
- final Function<PotentialSchemaSource<?>, SourceIdentifier> potSourceToSID =
- PotentialSchemaSource::getSourceIdentifier;
- assertThat(Collections2.transform(listener.registeredSources, potSourceToSID),
- both(hasItem(RevisionSourceIdentifier.create("test", Optional.absent())))
+ assertThat(Lists.transform(listener.registeredSources, PotentialSchemaSource::getSourceIdentifier),
+ both(hasItem(RevisionSourceIdentifier.create("test", Optional.empty())))
.and(hasItem(RevisionSourceIdentifier.create("test", Optional.of("2012-12-12"))))
.and(hasItem(RevisionSourceIdentifier.create("test", Optional.of("2013-12-12"))))
.and(hasItem(RevisionSourceIdentifier.create("module", Optional.of("2010-12-12"))))
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.io.IOException;
import java.net.URL;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.collect.Sets;
+import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.Date;
import java.util.Optional;
final ModuleIdentifier bar = ModuleIdentifierImpl.create("bar", Optional.of(new URI("bar")), date);
final ModuleIdentifier sub1Bar = ModuleIdentifierImpl.create("sub1-bar", Optional.of(new URI("bar")), date);
final ModuleIdentifier baz = ModuleIdentifierImpl.create("baz", Optional.of(new URI("baz")), date);
- final Set<ModuleIdentifier> testSet = Sets.newHashSet(foo, sub1Foo, sub2Foo, bar, sub1Bar, baz);
+ final Set<ModuleIdentifier> testSet = ImmutableSet.of(foo, sub1Foo, sub2Foo, bar, sub1Bar, baz);
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6961/");
assertNotNull(context);
final Set<ModuleIdentifier> allModuleIdentifiers = context.getAllModuleIdentifiers();
*/
package org.opendaylight.yangtools.yang.thirdparty.plugin;
+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;
import org.opendaylight.yangtools.yang.common.QName;
final Class<? extends DeclaredStatement<?>> declared,
final Class<? extends EffectiveStatement<?, ?>> effective, final String nameStr, final String argumentStr,
final boolean yinElement) {
- type = Preconditions.checkNotNull(declared);
- effectiveType = Preconditions.checkNotNull(effective);
+ type = requireNonNull(declared);
+ effectiveType = requireNonNull(effective);
name = createQName(namespace, revision, nameStr);
argument = createQName(namespace, revision, argumentStr);
this.yinElement = yinElement;
ThirdPartyExtensionsMapping(final String namespace, final Class<? extends DeclaredStatement<?>> declared,
final Class<? extends EffectiveStatement<?, ?>> effective, final String nameStr, final String argumentStr,
final boolean yinElement) {
- type = Preconditions.checkNotNull(declared);
- effectiveType = Preconditions.checkNotNull(effective);
+ type = requireNonNull(declared);
+ effectiveType = requireNonNull(effective);
name = createQName(namespace, nameStr);
argument = createQName(namespace, argumentStr);
this.yinElement = yinElement;
package org.opendaylight.yangtools.yang.parser.spi.meta;
-import com.google.common.base.Optional;
-import com.google.common.base.Predicates;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
import java.util.Collection;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
}
protected final <S extends DeclaredStatement<?>> S firstDeclared(final Class<S> type) {
- final Optional<? extends DeclaredStatement<?>> declaredSubstmt = Iterables.tryFind(substatements,
- Predicates.instanceOf(type));
- return declaredSubstmt.isPresent() ? type.cast(declaredSubstmt.get()) : null;
+ return substatements.stream().filter(type::isInstance).findFirst().map(type::cast).orElse(null);
}
@Override
return source;
}
- @SuppressWarnings("unchecked")
protected final <S extends DeclaredStatement<?>> Collection<? extends S> allDeclared(final Class<S> type) {
- return Collection.class.cast(Collections2.filter(substatements, Predicates.instanceOf(type)));
+ return Collections2.transform(Collections2.filter(substatements, type::isInstance), type::cast);
}
}
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
private final StatementDefinition type;
protected AbstractStatementSupport(final StatementDefinition publicDefinition) {
- Preconditions.checkArgument(publicDefinition != this);
- this.type = Preconditions.checkNotNull(publicDefinition);
+ this.type = requireNonNull(publicDefinition);
+ checkArgument(publicDefinition != this);
}
@Nonnull
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Map;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
private final Class<DN> derivedFrom;
- protected DerivedNamespaceBehaviour(Class<N> identifier, Class<DN> derivedFrom) {
+ protected DerivedNamespaceBehaviour(final Class<N> identifier, final Class<DN> derivedFrom) {
super(identifier);
- this.derivedFrom = Preconditions.checkNotNull(derivedFrom);
+ this.derivedFrom = requireNonNull(derivedFrom);
}
public Class<DN> getDerivedFrom() {
}
@Override
- public Map<K, V> getAllFrom(NamespaceStorageNode storage) {
+ public Map<K, V> getAllFrom(final NamespaceStorageNode storage) {
throw new UnsupportedOperationException("Virtual namespaces does not support provision of all items.");
}
public abstract V getFrom(NamespaceBehaviour.NamespaceStorageNode storage, K key);
@Override
- public void addTo(NamespaceStorageNode storage, K key, V value) {
+ public void addTo(final NamespaceStorageNode storage, final K key, final V value) {
// Intentional noop
}
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
private final Class<N> identifier;
protected NamespaceBehaviour(final Class<N> identifier) {
- this.identifier = Preconditions.checkNotNull(identifier);
+ this.identifier = requireNonNull(identifier);
}
/**
StorageSpecific(final Class<N> identifier, final StorageNodeType type) {
super(identifier);
- storageType = Preconditions.checkNotNull(type);
+ storageType = requireNonNull(type);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
/**
* Thrown when identifier namespace is not available (supported) in a specific model processing phase.
private static final long serialVersionUID = 1L;
- public NamespaceNotAvailableException(String message) {
- super(Preconditions.checkNotNull(message));
+ public NamespaceNotAvailableException(final String message) {
+ super(requireNonNull(message));
}
- public NamespaceNotAvailableException(String message, Throwable cause) {
- super(Preconditions.checkNotNull(message), cause);
+ public NamespaceNotAvailableException(final String message, final Throwable cause) {
+ super(requireNonNull(message), cause);
}
}
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
public class ReactorException extends Exception {
public ReactorException(final ModelProcessingPhase phase, final String message, final SourceIdentifier sourceId,
final Throwable cause) {
super(message, cause);
- this.phase = Preconditions.checkNotNull(phase);
+ this.phase = requireNonNull(phase);
this.sourceIdentifier = sourceId;
}
public ReactorException(final ModelProcessingPhase phase, final String message, final SourceIdentifier sourceId) {
super(message);
- this.phase = Preconditions.checkNotNull(phase);
+ this.phase = requireNonNull(phase);
this.sourceIdentifier = sourceId;
}
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.ImmutableMap;
}
public static Builder derivedFrom(final StatementSupportBundle parent) {
- Preconditions.checkNotNull(parent);
return new Builder(parent.getSupportedVersions(), parent);
}
final Class<N> namespace) throws NamespaceNotAvailableException {
final NamespaceBehaviour<?, ?, ?> potential = namespaceDefinitions.get(namespace);
if (potential != null) {
- Preconditions.checkState(namespace.equals(potential.getIdentifier()));
+ checkState(namespace.equals(potential.getIdentifier()));
// Safe cast, previous checkState checks equivalence of key from which type argument are derived
return (NamespaceBehaviour<K, V, N>) potential;
private StatementSupportBundle parent;
Builder(final Set<YangVersion> supportedVersions, final StatementSupportBundle parent) {
- this.parent = Preconditions.checkNotNull(parent);
+ this.parent = requireNonNull(parent);
this.supportedVersions = ImmutableSet.copyOf(supportedVersions);
}
public Builder addSupport(final StatementSupport<?, ?, ?> definition) {
final QName identifier = definition.getStatementName();
- Preconditions.checkState(!commonStatements.containsKey(identifier),
+ checkState(!commonStatements.containsKey(identifier),
"Statement %s already defined in common statement bundle.", identifier);
- Preconditions.checkState(parent.getCommonStatementDefinition(identifier) == null,
+ checkState(parent.getCommonStatementDefinition(identifier) == null,
"Statement %s already defined.", identifier);
commonStatements.put(identifier, definition);
return this;
public <K, V, N extends IdentifierNamespace<K, V>> Builder addSupport(
final NamespaceBehaviour<K, V, N> namespaceSupport) {
final Class<N> identifier = namespaceSupport.getIdentifier();
- Preconditions.checkState(!namespaces.containsKey(identifier));
- Preconditions.checkState(!parent.hasNamespaceBehaviour(identifier));
+ checkState(!namespaces.containsKey(identifier));
+ checkState(!parent.hasNamespaceBehaviour(identifier));
namespaces.put(identifier, namespaceSupport);
return this;
}
public Builder addVersionSpecificSupport(final YangVersion version,
final StatementSupport<?, ?, ?> definition) {
- Preconditions.checkNotNull(version);
- Preconditions.checkNotNull(definition);
- Preconditions.checkArgument(supportedVersions.contains(version));
+ checkArgument(supportedVersions.contains(requireNonNull(version)));
final QName identifier = definition.getStatementName();
- Preconditions.checkState(!commonStatements.containsKey(identifier),
+ checkState(!commonStatements.containsKey(identifier),
"Statement %s already defined in common statement bundle.", identifier);
- Preconditions.checkState(!versionSpecificStatements.contains(version, identifier),
+ checkState(!versionSpecificStatements.contains(version, identifier),
"Statement %s already defined for version %s.", identifier, version);
- Preconditions.checkState(parent.getCommonStatementDefinition(identifier) == null,
+ checkState(parent.getCommonStatementDefinition(identifier) == null,
"Statement %s already defined in parent's common statement bundle.", identifier);
- Preconditions.checkState(parent.getVersionSpecificStatementDefinition(version, identifier) == null,
+ checkState(parent.getVersionSpecificStatementDefinition(version, identifier) == null,
"Statement %s already defined for version %s in parent's statement bundle.", identifier, version);
versionSpecificStatements.put(version, identifier, definition);
return this;
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
*/
public static boolean hasAncestorOfType(final StmtContext<?, ?, ?> ctx,
final Collection<StatementDefinition> ancestorTypes) {
- Preconditions.checkNotNull(ctx);
- Preconditions.checkNotNull(ancestorTypes);
+ requireNonNull(ancestorTypes);
StmtContext<?, ?, ?> current = ctx.getParentContext();
while (current != null) {
if (ancestorTypes.contains(current.getPublicDefinition())) {
public static <A, D extends DeclaredStatement<A>> boolean hasAncestorOfTypeWithChildOfType(
final StmtContext<?, ?, ?> ctx, final StatementDefinition ancestorType,
final StatementDefinition ancestorChildType) {
- Preconditions.checkNotNull(ctx);
- Preconditions.checkNotNull(ancestorType);
- Preconditions.checkNotNull(ancestorChildType);
+ requireNonNull(ctx);
+ requireNonNull(ancestorType);
+ requireNonNull(ancestorChildType);
StmtContext<?, ?, ?> current = ctx.getParentContext();
StmtContext<?, ?, ?> parent = current.getParentContext();
* @return true if the parent of StmtContext is of specified type, otherwise false
*/
public static boolean hasParentOfType(final StmtContext<?, ?, ?> ctx, final StatementDefinition parentType) {
- Preconditions.checkNotNull(ctx);
- Preconditions.checkNotNull(parentType);
+ requireNonNull(parentType);
final StmtContext<?, ?, ?> parentContext = ctx.getParentContext();
return parentContext != null ? parentType.equals(parentContext.getPublicDefinition()) : false;
}
* @param ctx statement context to be validated
*/
public static void validateIfFeatureAndWhenOnListKeys(final StmtContext<?, ?, ?> ctx) {
- Preconditions.checkNotNull(ctx);
-
if (!isRelevantForIfFeatureAndWhenOnListKeysCheck(ctx)) {
return;
}
qnameModule = null;
}
- Preconditions.checkArgument(qnameModule != null, "Failed to look up root QNameModule for %s", ctx);
+ checkArgument(qnameModule != null, "Failed to look up root QNameModule for %s", ctx);
if (qnameModule.getRevision() != null) {
return qnameModule;
}
*/
package org.opendaylight.yangtools.yang.parser.spi.source;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
/**
private final StatementSourceReference parentRef;
private ImplicitSubstatement(final StatementSourceReference parentRef) {
- this.parentRef = Preconditions.checkNotNull(parentRef);
+ this.parentRef = requireNonNull(parentRef);
}
/**
*/
package org.opendaylight.yangtools.yang.parser.spi.source;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
public void put(final QName qname, final StatementSupport<?, ?, ?> stDef) {
// HashMap does not guard against nulls
- Preconditions.checkNotNull(qname);
- Preconditions.checkNotNull(stDef);
-
- qnameToSupport.put(qname, stDef);
+ qnameToSupport.put(requireNonNull(qname), requireNonNull(stDef));
putNoRev(qname, stDef);
}
public void putAll(final Map<QName, StatementSupport<?, ?, ?>> qnameToStmt) {
qnameToSupport.putAll(qnameToStmt);
- qnameToStmt.forEach((this::putNoRev));
+ qnameToStmt.forEach(this::putNoRev);
}
public StatementSupport<?, ?, ?> putIfAbsent(final QName qname, final StatementSupport<?, ?, ?> support) {
*/
package org.opendaylight.yangtools.yang.parser.spi.source;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Optional;
import javax.annotation.Nonnull;
}
private static String createMessage(@Nonnull final String message, @Nonnull final StatementSourceReference source) {
- Preconditions.checkNotNull(message);
- Preconditions.checkNotNull(source);
+ requireNonNull(message);
+ requireNonNull(source);
return message + " [at " + source + ']';
}
Code Review / yangtools.git / commitdiff