Improve Decimal64 range support

[mdsal.git] / binding / mdsal-binding-java-api-generator / src / main / java / org / opendaylight / mdsal / binding / java / api / generator / AbstractPrimitiveRangeGenerator.java

diff --git a/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractPrimitiveRangeGenerator.java b/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractPrimitiveRangeGenerator.java
index d57f00daaee50cbe7d131a9b0ccfc8e1ba84a86f..e29a9a16be980e86470d01288cd015e586d8cc01 100644 (file)
--- a/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractPrimitiveRangeGenerator.java
+++ b/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractPrimitiveRangeGenerator.java
@@ -7,14 +7,15 @@
  */
 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;
@@ -22,15 +23,16 @@ import org.slf4j.LoggerFactory;
 
 abstract class AbstractPrimitiveRangeGenerator<T extends Number & Comparable<T>> extends AbstractRangeGenerator<T> {
     private static final Logger LOG = LoggerFactory.getLogger(AbstractPrimitiveRangeGenerator.class);
-    private final String primitiveName;
-    private final T minValue;
-    private final T maxValue;
+    private final @NonNull String primitiveName;
+    private final @NonNull T minValue;
+    private final @NonNull T maxValue;
 
-    protected AbstractPrimitiveRangeGenerator(final Class<T> typeClass, final String primitiveName, final T minValue, final T maxValue) {
+    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);
     }
 
     /**
@@ -38,7 +40,7 @@ abstract class AbstractPrimitiveRangeGenerator<T extends Number & Comparable<T>>
      *
      * @return Primitive type name
      */
-    @Nonnull protected final String getPrimitiveName() {
+    protected final @NonNull String getPrimitiveName() {
         return primitiveName;
     }
 
@@ -50,7 +52,8 @@ abstract class AbstractPrimitiveRangeGenerator<T extends Number & Comparable<T>>
         return minValue.compareTo(minToEnforce) < 0;
     }
 
-    private Collection<String> createExpressions(final RangeConstraint<?> constraint) {
+    private Collection<String> createExpressions(final RangeConstraint<?> constraint,
+            final Function<Class<?>, String> classImporter) {
         final Set<? extends Range<? extends Number>> constraints = constraint.getAllowedRanges().asRanges();
         final Collection<String> ret = new ArrayList<>(constraints.size());
 
@@ -68,13 +71,13 @@ abstract class AbstractPrimitiveRangeGenerator<T extends Number & Comparable<T>>
 
             final StringBuilder sb = new StringBuilder();
             if (needMin) {
-                sb.append("value >= ").append(format(min));
+                appendMinCheck(sb, min, classImporter);
             }
             if (needMax) {
                 if (needMin) {
                     sb.append(" && ");
                 }
-                sb.append("value <= ").append(format(max));
+                appendMaxCheck(sb, max, classImporter);
             }
 
             ret.add(sb.toString());
@@ -83,6 +86,27 @@ abstract class AbstractPrimitiveRangeGenerator<T extends Number & Comparable<T>>
         return ret;
     }
 
+    void appendMaxCheck(final StringBuilder sb, final T max, final Function<Class<?>, String> classImporter) {
+        sb.append("value <= ").append(format(max));
+    }
+
+    void appendMinCheck(final StringBuilder sb, final T min, final Function<Class<?>, String> classImporter) {
+        sb.append("value >= ").append(format(min));
+    }
+
+    /**
+     * Format a value into a Java-compilable expression which results in the appropriate
+     * type.
+     *
+     * @param value Number value
+     * @return Java language string representation
+     */
+    protected abstract @NonNull String format(T value);
+
+    String codeHelpersThrow() {
+        return "throwInvalidRange";
+    }
+
     private String createRangeString(final RangeConstraint<?> constraint) {
         final Set<? extends Range<? extends Number>> constraints = constraint.getAllowedRanges().asRanges();
         final List<Range<T>> ranges = new ArrayList<>(constraints.size());
@@ -98,9 +122,10 @@ abstract class AbstractPrimitiveRangeGenerator<T extends Number & Comparable<T>>
     protected final String generateRangeCheckerImplementation(final String checkerName,
             final RangeConstraint<?> constraints, final Function<Class<?>, String> classImporter) {
         final StringBuilder sb = new StringBuilder();
-        final Collection<String> expressions = createExpressions(constraints);
+        final Collection<String> expressions = createExpressions(constraints, classImporter);
 
-        sb.append("private static void ").append(checkerName).append("(final ").append(primitiveName).append(" value) {\n");
+        sb.append("private static void ").append(checkerName).append("(final ").append(primitiveName)
+            .append(" value) {\n");
 
         if (!expressions.isEmpty()) {
             for (String exp : expressions) {
@@ -109,12 +134,10 @@ abstract class AbstractPrimitiveRangeGenerator<T extends Number & Comparable<T>>
                 sb.append("    }\n");
             }
 
-            sb.append("    ").append(classImporter.apply(CodeHelpers.class)).append(".throwInvalidRange(\"")
-            .append(createRangeString(constraints)).append("\", value);\n");
+            sb.append("    ").append(classImporter.apply(CodeHelpers.class)).append('.').append(codeHelpersThrow())
+            .append("(\"").append(createRangeString(constraints)).append("\", value);\n");
         }
 
-        sb.append("}\n");
-
-        return sb.toString();
+        return sb.append("}\n").toString();
     }
 }