binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/range_generators/AbstractPrimitiveRangeGenerator.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.javav2.java.api.generator.range_generators;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.collect.Range;
  13 import java.util.ArrayList;
  14 import java.util.Collection;
  15 import java.util.Set;
  16 import javax.annotation.Nonnull;
  17 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  18 import org.slf4j.Logger;
  19 import org.slf4j.LoggerFactory;
  20
  21 abstract class AbstractPrimitiveRangeGenerator<T extends Number & Comparable<T>> extends AbstractRangeGenerator<T> {
  22     private static final Logger LOG = LoggerFactory.getLogger(AbstractPrimitiveRangeGenerator.class);
  23     private final String primitiveName;
  24     private final T minValue;
  25     private final T maxValue;
  26
  27     protected AbstractPrimitiveRangeGenerator(final Class<T> typeClass, final String primitiveName, final T minValue,
  28             final T maxValue) {
  29         super(typeClass);
  30         this.primitiveName = requireNonNull(primitiveName);
  31         this.minValue = requireNonNull(minValue);
  32         this.maxValue = requireNonNull(maxValue);
  33     }
  34
  35     /**
  36      * Return the name of the primitive type, as known by the Java language.
  37      *
  38      * @return Primitive type name
  39      */
  40     @Nonnull protected final String getPrimitiveName() {
  41         return primitiveName;
  42     }
  43
  44     private boolean needsMaximumEnforcement(final T maxToEnforce) {
  45         return maxValue.compareTo(maxToEnforce) > 0;
  46     }
  47
  48     private boolean needsMinimumEnforcement(final T minToEnforce) {
  49         return minValue.compareTo(minToEnforce) < 0;
  50     }
  51
  52     /**
  53      * Format a value into a Java-compilable 'greater equal' compare expression.
  54      * The method would be overrided by {@link AbstractUnsignedIntegerRangeGenerator}.
  55      *
  56      * @param value Number value
  57      * @return Java language compare string representation
  58      */
  59     @Nonnull protected String gtExpression(T value) {
  60         return "value >= " + format(value);
  61     }
  62
  63     /**
  64      * Format a value into a Java-compilable 'less equal' compare expression.
  65      * The method would be overrided by {@link AbstractUnsignedIntegerRangeGenerator}.
  66      *
  67      * @param value Number value
  68      * @return Java language compare string representation
  69      */
  70     @Nonnull protected String ltExpression(T value) {
  71         return "value <= " + format(value);
  72     }
  73
  74     private Collection<String> createExpressions(final RangeConstraint<?> constraint) {
  75         final Set<? extends Range<? extends Number>> constraints = constraint.getAllowedRanges().asRanges();
  76         final Collection<String> ret = new ArrayList<>(constraints.size());
  77
  78         for (Range<? extends Number> r : constraints) {
  79             final T min = getValue(r.lowerEndpoint());
  80             final boolean needMin = needsMinimumEnforcement(min);
  81
  82             final T max = getValue(r.upperEndpoint());
  83             final boolean needMax = needsMaximumEnforcement(max);
  84
  85             if (!needMin && !needMax) {
  86                 LOG.debug("Type {} indicates [{}, {}] does not require enforcement", getTypeName(), min, max);
  87                 continue;
  88             }
  89
  90             final StringBuilder sb = new StringBuilder();
  91             if (needMin) {
  92                 sb.append(gtExpression(min));
  93             }
  94             if (needMax) {
  95                 if (needMin) {
  96                     sb.append(" && ");
  97                 }
  98                 sb.append(ltExpression(max));
  99             }
 100
 101             ret.add(sb.toString());
 102         }
 103
 104         return ret;
 105     }
 106
 107     private static String createRangeString(final RangeConstraint<?> constraints) {
 108         return constraints.getAllowedRanges().toString();
 109     }
 110
 111     @Override
 112     protected final String generateRangeCheckerImplementation(final String checkerName,
 113             final RangeConstraint<?> constraint) {
 114         final StringBuilder sb = new StringBuilder();
 115         final Collection<String> expressions = createExpressions(constraint);
 116
 117         sb.append("private static void ").append(checkerName).append("(final ").append(primitiveName)
 118             .append(" value) {\n");
 119
 120         if (!expressions.isEmpty()) {
 121             for (String exp : expressions) {
 122                 sb.append("    if (").append(exp).append(") {\n");
 123                 sb.append("        return;\n");
 124                 sb.append("    }\n");
 125             }
 126
 127             sb.append("    throw new IllegalArgumentException(String.format(\"Invalid range: %s, expected: ")
 128               .append(createRangeString(constraint)).append(".\", value));\n");
 129         }
 130
 131         sb.append("}\n");
 132
 133         return sb.toString();
 134     }
 135 }