*/
package org.opendaylight.mdsal.binding.java.api.generator;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Range;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.binding.CodeHelpers;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.slf4j.Logger;
private final T minValue;
private final T maxValue;
- protected AbstractPrimitiveRangeGenerator(final Class<T> typeClass, final String primitiveName, final T minValue, final T maxValue) {
+ protected AbstractPrimitiveRangeGenerator(final Class<T> typeClass, final String primitiveName, final T minValue,
+ final T maxValue) {
super(typeClass);
- this.primitiveName = Preconditions.checkNotNull(primitiveName);
- this.minValue = Preconditions.checkNotNull(minValue);
- this.maxValue = Preconditions.checkNotNull(maxValue);
+ this.primitiveName = requireNonNull(primitiveName);
+ this.minValue = requireNonNull(minValue);
+ this.maxValue = requireNonNull(maxValue);
}
/**
*
* @return Primitive type name
*/
- @Nonnull protected final String getPrimitiveName() {
+ protected final @NonNull String getPrimitiveName() {
return primitiveName;
}
*/
package org.opendaylight.mdsal.binding.java.api.generator;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import java.util.Map;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
private static final Logger LOG = LoggerFactory.getLogger(AbstractRangeGenerator.class);
private static final Map<String, AbstractRangeGenerator<?>> GENERATORS;
- private static void addGenerator(final Builder<String, AbstractRangeGenerator<?>> b, final AbstractRangeGenerator<?> generator) {
+ private static void addGenerator(final Builder<String, AbstractRangeGenerator<?>> b,
+ final AbstractRangeGenerator<?> generator) {
b.put(generator.getTypeClass().getCanonicalName(), generator);
}
private final Class<T> type;
protected AbstractRangeGenerator(final Class<T> typeClass) {
- this.type = Preconditions.checkNotNull(typeClass);
+ this.type = requireNonNull(typeClass);
}
- static AbstractRangeGenerator<?> forType(@Nonnull final Type type) {
+ static AbstractRangeGenerator<?> forType(final @NonNull Type type) {
final ConcreteType javaType = TypeUtils.getBaseYangType(type);
return GENERATORS.get(javaType.getFullyQualifiedName());
}
*
* @return A class object
*/
- @Nonnull protected final Class<T> getTypeClass() {
+ protected final @NonNull Class<T> getTypeClass() {
return type;
}
*
* @return Fully-qualified name
*/
- @Nonnull protected final String getTypeName() {
+ protected final @NonNull String getTypeName() {
return type.getName();
}
* @param value Value as a Number
* @return Value in native format.
*/
- @Nonnull protected final T getValue(final Number value) {
+ protected final @NonNull T getValue(final Number value) {
if (type.isInstance(value)) {
return type.cast(value);
}
* @param value Number value
* @return Java language string representation
*/
- @Nonnull protected abstract String format(T value);
+ protected abstract @NonNull String format(T value);
/**
* Generate the checker method source code.
* @param constraints Restrictions which need to be applied.
* @return Method source code.
*/
- @Nonnull protected abstract String generateRangeCheckerImplementation(@Nonnull String checkerName,
- @Nonnull RangeConstraint<?> constraints, Function<Class<?>, String> classImporter);
+ protected abstract @NonNull String generateRangeCheckerImplementation(@NonNull String checkerName,
+ @NonNull RangeConstraint<?> constraints, Function<Class<?>, String> classImporter);
private static String rangeCheckerName(final String member) {
return "check" + member + "Range";
}
- String generateRangeChecker(@Nonnull final String member, @Nonnull final RangeConstraint<?> constraints,
+ String generateRangeChecker(final @NonNull String member, final @NonNull RangeConstraint<?> constraints,
final JavaFileTemplate template) {
return generateRangeCheckerImplementation(rangeCheckerName(member), constraints, template::importedName);
}
- String generateRangeCheckerCall(@Nonnull final String member, @Nonnull final String valueReference) {
+ String generateRangeCheckerCall(final @NonNull String member, final @NonNull String valueReference) {
return rangeCheckerName(member) + '(' + valueReference + ");\n";
}
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.Set;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.binding.CodeHelpers;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
: generateStringLengthChecker(member, constraint, template);
}
- static String generateLengthCheckerCall(@Nullable final String member, @Nonnull final String valueReference) {
+ static String generateLengthCheckerCall(final @Nullable String member, final @NonNull String valueReference) {
return lengthCheckerName(member) + '(' + valueReference + ");\n";
}
}
*/
package org.opendaylight.mdsal.binding.java.api.generator;
-import com.google.common.base.Preconditions;
-import javax.annotation.Nonnull;
+import static com.google.common.base.Preconditions.checkArgument;
+
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
* @param type Input Type object
* @return Resolved {@link ConcreteType} instance.
*/
- static ConcreteType getBaseYangType(@Nonnull final Type type) {
+ static ConcreteType getBaseYangType(final @NonNull Type type) {
// Already the correct type
if (type instanceof ConcreteType) {
return (ConcreteType) type;
}
- Preconditions.checkArgument(type instanceof GeneratedTransferObject, "Unsupported type %s", type);
+ checkArgument(type instanceof GeneratedTransferObject, "Unsupported type %s", type);
// Need to walk up the GTO chain to the root
GeneratedTransferObject rootGto = (GeneratedTransferObject) type;