Split out isBitsType()

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

diff --git a/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractRangeGenerator.java b/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractRangeGenerator.java
index fee91319c48589294716d069afadddee892d8320..50e9798df83bff52d216f32320b35ec0169c9736 100644 (file)
--- a/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractRangeGenerator.java
+++ b/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractRangeGenerator.java
@@ -7,6 +7,7 @@
  */
 package org.opendaylight.mdsal.binding.java.api.generator;
 
+import static com.google.common.base.Verify.verifyNotNull;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.collect.ImmutableMap;
@@ -29,25 +30,32 @@ abstract class AbstractRangeGenerator<T extends Number & Comparable<T>> {
     }
 
     static {
-        final Builder<String, AbstractRangeGenerator<?>> b = ImmutableMap.<String, AbstractRangeGenerator<?>>builder();
+        final Builder<String, AbstractRangeGenerator<?>> b = ImmutableMap.builder();
         addGenerator(b, new ByteRangeGenerator());
         addGenerator(b, new ShortRangeGenerator());
         addGenerator(b, new IntegerRangeGenerator());
         addGenerator(b, new LongRangeGenerator());
-        addGenerator(b, new BigDecimalRangeGenerator());
-        addGenerator(b, new BigIntegerRangeGenerator());
+        addGenerator(b, new Decimal64RangeGenerator());
+        addGenerator(b, new Uint8RangeGenerator());
+        addGenerator(b, new Uint16RangeGenerator());
+        addGenerator(b, new Uint32RangeGenerator());
+        addGenerator(b, new Uint64RangeGenerator());
         GENERATORS = b.build();
     }
 
-    private final Class<T> type;
+    private final @NonNull Class<T> type;
 
     protected AbstractRangeGenerator(final Class<T> typeClass) {
         this.type = requireNonNull(typeClass);
     }
 
-    static AbstractRangeGenerator<?> forType(final @NonNull Type type) {
+    static @NonNull AbstractRangeGenerator<?> forType(final @NonNull Type type) {
         final ConcreteType javaType = TypeUtils.getBaseYangType(type);
-        return GENERATORS.get(javaType.getFullyQualifiedName());
+        return forName(javaType.getFullyQualifiedName());
+    }
+
+    private static @NonNull AbstractRangeGenerator<?> forName(final String fqcn) {
+        return verifyNotNull(GENERATORS.get(fqcn), "Unhandled type %s", fqcn);
     }
 
     /**
@@ -83,7 +91,7 @@ abstract class AbstractRangeGenerator<T extends Number & Comparable<T>> {
         final T ret = convert(value);
 
         // Check if the conversion lost any precision by performing conversion the other way around
-        final AbstractRangeGenerator<?> gen = GENERATORS.get(value.getClass().getName());
+        final AbstractRangeGenerator<?> gen = forName(value.getClass().getName());
         final Number check = gen.convert(ret);
         if (!value.equals(check)) {
             LOG.warn("Number class conversion from {} to {} truncated value {} to {}", value.getClass(), type, value,
@@ -97,15 +105,6 @@ abstract class AbstractRangeGenerator<T extends Number & Comparable<T>> {
     @Deprecated
     protected abstract T convert(Number value);
 
-    /**
-     * 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);
-
     /**
      * Generate the checker method source code.
      * @param checkerName Name of the checker method.
@@ -115,7 +114,7 @@ abstract class AbstractRangeGenerator<T extends Number & Comparable<T>> {
     protected abstract @NonNull String generateRangeCheckerImplementation(@NonNull String checkerName,
             @NonNull RangeConstraint<?> constraints, Function<Class<?>, String> classImporter);
 
-    private static String rangeCheckerName(final String member) {
+    private static @NonNull String rangeCheckerName(final String member) {
         return "check" + member + "Range";
     }
 
@@ -125,6 +124,10 @@ abstract class AbstractRangeGenerator<T extends Number & Comparable<T>> {
     }
 
     String generateRangeCheckerCall(final @NonNull String member, final @NonNull String valueReference) {
-        return rangeCheckerName(member) + '(' + valueReference + ");\n";
+        return rangeCheckerName(member) + '(' + valueReference + primitiveRef() + ");\n";
+    }
+
+    String primitiveRef() {
+        return "";
     }
 }