Make RangeRestrictedTypeDefinition type-aware

This brings in native type into RangeRestrictedTypeDefinition, such
that the constraint type is properly qualified.

Change-Id: I1e099edb88abe882de0e937a43629693f1d660e6
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/AbstractIntegerStringCodec.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/AbstractIntegerStringCodec.java
index c50e83434e59705867f86b189e7bb25438246947..588dd36910ead6437bae1b32a9d6fa44a77656bb 100644 (file)
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/AbstractIntegerStringCodec.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/AbstractIntegerStringCodec.java
@@ -21,6 +21,7 @@ import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
+import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
@@ -50,10 +51,10 @@ public abstract class AbstractIntegerStringCodec<N extends Number & Comparable<N
 
     private final RangeSet<N> rangeConstraints;
 
-    AbstractIntegerStringCodec(final Optional<T> typeDefinition, final Optional<RangeConstraint<?>> constraint,
+    AbstractIntegerStringCodec(final Optional<T> typeDefinition, final Optional<RangeConstraint<N>> constraint,
         final Class<N> outputClass) {
         super(typeDefinition, outputClass);
-        rangeConstraints = (RangeSet<N>) constraint.map(RangeConstraint::getAllowedRanges).orElse(null);
+        rangeConstraints = constraint.map(RangeConstraint::getAllowedRanges).orElse(null);
     }
 
     public static AbstractIntegerStringCodec<?, ? extends IntegerTypeDefinition<?, ?>> from(
@@ -116,11 +117,8 @@ public abstract class AbstractIntegerStringCodec<N extends Number & Comparable<N
         }
     }
 
-    protected static Optional<RangeConstraint<?>> extractRange(final IntegerTypeDefinition<?, ?> type) {
-        return type == null ? Optional.empty() : type.getRangeConstraint();
-    }
-
-    protected static Optional<RangeConstraint<?>> extractRange(final UnsignedIntegerTypeDefinition<?, ?> type) {
+    protected static <N extends Number & Comparable<N>> Optional<RangeConstraint<N>> extractRange(
+            final RangeRestrictedTypeDefinition<?, N> type) {
         return type == null ? Optional.empty() : type.getRangeConstraint();
     }
 

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/UnresolvedNumber.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/UnresolvedNumber.java
index abe91ac1cb3dcc5d42216aad2fcbce391c51ccf5..4d65f61f1d77f3ef5c447ab7ee9f8d44a3063c6c 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/UnresolvedNumber.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/UnresolvedNumber.java
@@ -11,6 +11,7 @@ import static com.google.common.base.Preconditions.checkArgument;
 
 import com.google.common.annotations.Beta;
 import com.google.common.collect.Range;
+import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.concepts.Immutable;
 
 @Beta
@@ -95,9 +96,9 @@ public abstract class UnresolvedNumber extends Number implements Immutable {
         return number;
     }
 
-    public abstract <T extends Number & Comparable<T>> T resolveLength(Range<? extends T> span);
+    public abstract <T extends Number & Comparable<T>> @NonNull T resolveLength(Range<? extends T> span);
 
-    public abstract <T extends Number & Comparable<T>> T resolveRange(Range<? extends T> span);
+    public abstract <T extends Number & Comparable<T>> @NonNull T resolveRange(Range<? extends T> span);
 
     @Override
     public abstract String toString();

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/DecimalTypeDefinition.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/DecimalTypeDefinition.java
index 31b768888ce042905924ff57c27c42b128430ceb..5f1ebe09df559705d3ffc1f5221ed598fb5b9b5a 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/DecimalTypeDefinition.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/DecimalTypeDefinition.java
@@ -7,11 +7,13 @@
  */
 package org.opendaylight.yangtools.yang.model.api.type;
 
+import java.math.BigDecimal;
+
 /**
  * Contains methods for getting data from the YANG <code>type</code> substatement for <code>decimal64</code> built-in
  * type.
  */
-public interface DecimalTypeDefinition extends RangeRestrictedTypeDefinition<DecimalTypeDefinition> {
+public interface DecimalTypeDefinition extends RangeRestrictedTypeDefinition<DecimalTypeDefinition, BigDecimal> {
     /**
      * Returns integer between 1 and 18 inclusively.
      *

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/IntegerTypeDefinition.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/IntegerTypeDefinition.java
index f22c000922c340bd7639306ff2b578c4da470c9e..19fdcaac201bdd2a0ada0ed568ada45ac0da8402 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/IntegerTypeDefinition.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/IntegerTypeDefinition.java
@@ -28,6 +28,6 @@ package org.opendaylight.yangtools.yang.model.api.type;
  * @param <T> concrete type definition
  */
 public interface IntegerTypeDefinition<N extends Number & Comparable<N>, T extends IntegerTypeDefinition<N, T>>
-    extends RangeRestrictedTypeDefinition<T> {
+    extends RangeRestrictedTypeDefinition<T, N> {
 
 }

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/RangeConstraint.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/RangeConstraint.java
index 7d8da64e1af79619fdbe97a438b3732089764fdd..9a6595eaab203e280e46f500fae3f98e949359c8 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/RangeConstraint.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/RangeConstraint.java
@@ -20,5 +20,5 @@ public interface RangeConstraint<T extends Number & Comparable<T>> extends Const
      *
      * @return Set of allowed lengths.
      */
-    RangeSet<? extends T> getAllowedRanges();
+    RangeSet<T> getAllowedRanges();
 }

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/RangeRestrictedTypeDefinition.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/RangeRestrictedTypeDefinition.java
index cb5efac9d4563fbc64c28f86759d909a4cd879d3..55c15ecc82e61c362c2c4020fc65d817ac7ff0d0 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/RangeRestrictedTypeDefinition.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/RangeRestrictedTypeDefinition.java
@@ -14,8 +14,10 @@ import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  * Interface for {@link TypeDefinition}s which can have their values restricted to a set of allowed values.
  *
  * @param <T> Concrete {@link TypeDefinition} subinterface
+ * @param <N> Native data type
  */
-public interface RangeRestrictedTypeDefinition<T extends TypeDefinition<T>> extends TypeDefinition<T> {
+public interface RangeRestrictedTypeDefinition<T extends TypeDefinition<T>, N extends Number & Comparable<N>>
+        extends TypeDefinition<T> {
     /**
      * Returns range constraint of this type, if applicable. This is the effective constraint, e.g. it includes any
      * range constraints implied by base type hierarchy.
@@ -23,5 +25,5 @@ public interface RangeRestrictedTypeDefinition<T extends TypeDefinition<T>> exte
      * @return range constraint which are specified in the <code>range</code> substatement of the <code>type</code>
      *         statement.
      */
-    Optional<RangeConstraint<?>> getRangeConstraint();
+    Optional<RangeConstraint<N>> getRangeConstraint();
 }

diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/UnsignedIntegerTypeDefinition.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/UnsignedIntegerTypeDefinition.java
index f24282f5c09fb61d98fabb17fbcdbd15236a5b1b..29a3550fe3b99388172d869737867f4d5493f45e 100644 (file)
--- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/UnsignedIntegerTypeDefinition.java
+++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/type/UnsignedIntegerTypeDefinition.java
@@ -17,6 +17,6 @@ package org.opendaylight.yangtools.yang.model.api.type;
  * @param <T> concrete type definition
  */
 public interface UnsignedIntegerTypeDefinition<N extends Number & Comparable<N>,
-        T extends UnsignedIntegerTypeDefinition<N, T>> extends RangeRestrictedTypeDefinition<T> {
+        T extends UnsignedIntegerTypeDefinition<N, T>> extends RangeRestrictedTypeDefinition<T, N> {
 
 }

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedBaseType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedBaseType.java
index 895400b9be9a1939c15723f97537cf9dc6f775f0..868a0f0d989764ffe6fe89a362f0cc7f19e5ce0f 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedBaseType.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedBaseType.java
@@ -21,8 +21,8 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
 
-abstract class AbstractRangeRestrictedBaseType<T extends RangeRestrictedTypeDefinition<T>,
-    C extends Number & Comparable<C>> extends AbstractBaseType<T> implements RangeRestrictedTypeDefinition<T> {
+abstract class AbstractRangeRestrictedBaseType<T extends RangeRestrictedTypeDefinition<T, N>,
+    N extends Number & Comparable<N>> extends AbstractBaseType<T> implements RangeRestrictedTypeDefinition<T, N> {
     private static final ConstraintMetaDefinition BUILTIN_CONSTRAINT = new ConstraintMetaDefinition() {
 
         @Override
@@ -46,23 +46,23 @@ abstract class AbstractRangeRestrictedBaseType<T extends RangeRestrictedTypeDefi
         }
     };
 
-    private final RangeConstraint<?> rangeConstraint;
+    private final RangeConstraint<N> rangeConstraint;
 
-    AbstractRangeRestrictedBaseType(final QName qname, final C minValue, final C maxValue) {
+    AbstractRangeRestrictedBaseType(final QName qname, final N minValue, final N maxValue) {
         super(qname);
         this.rangeConstraint = new ResolvedRangeConstraint<>(BUILTIN_CONSTRAINT, ImmutableRangeSet.of(
             Range.closed(minValue, maxValue)));
     }
 
     AbstractRangeRestrictedBaseType(final SchemaPath path, final List<UnknownSchemaNode> unknownSchemaNodes,
-        final RangeConstraint<?> rangeConstraint) {
+        final RangeConstraint<N> rangeConstraint) {
         super(path, unknownSchemaNodes);
         this.rangeConstraint = requireNonNull(rangeConstraint);
     }
 
     @Override
     @Nonnull
-    public final Optional<RangeConstraint<?>> getRangeConstraint() {
+    public final Optional<RangeConstraint<N>> getRangeConstraint() {
         return Optional.of(rangeConstraint);
     }
 }

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedDerivedType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedDerivedType.java
index 2237f0220c7ee3c2bf0c301a23aea1825378a535..f0cb11bca30779717014e1ed97a9457f3fc0684f 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedDerivedType.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedDerivedType.java
@@ -16,8 +16,9 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
 
-abstract class AbstractRangeRestrictedDerivedType<T extends RangeRestrictedTypeDefinition<T>>
-        extends AbstractDerivedType<T> implements RangeRestrictedTypeDefinition<T> {
+abstract class AbstractRangeRestrictedDerivedType<T extends RangeRestrictedTypeDefinition<T, N>,
+        N extends Number & Comparable<N>> extends AbstractDerivedType<T>
+        implements RangeRestrictedTypeDefinition<T, N> {
 
     AbstractRangeRestrictedDerivedType(final T baseType, final SchemaPath path,
             final Object defaultValue, final String description, final String reference, final Status status,
@@ -27,7 +28,7 @@ abstract class AbstractRangeRestrictedDerivedType<T extends RangeRestrictedTypeD
 
     @Nonnull
     @Override
-    public final Optional<RangeConstraint<?>> getRangeConstraint() {
+    public final Optional<RangeConstraint<N>> getRangeConstraint() {
         return baseType().getRangeConstraint();
     }
 }

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedType.java
index bd1af45b0b2892b9c47dd13347ae74c684d8a497..fc88af6a8fb76cd6d20e627dae103d7fb9ef926b 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedType.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRangeRestrictedType.java
@@ -16,19 +16,20 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
 
-abstract class AbstractRangeRestrictedType<T extends RangeRestrictedTypeDefinition<T>>
-        extends AbstractRestrictedType<T> implements RangeRestrictedTypeDefinition<T> {
-    private final @Nullable RangeConstraint<?> rangeConstraint;
+abstract class AbstractRangeRestrictedType<T extends RangeRestrictedTypeDefinition<T, N>,
+        N extends Number & Comparable<N>> extends AbstractRestrictedType<T>
+        implements RangeRestrictedTypeDefinition<T, N> {
+    private final @Nullable RangeConstraint<N> rangeConstraint;
 
     AbstractRangeRestrictedType(final T baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<N> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes);
         this.rangeConstraint = rangeConstraint;
     }
 
     @Override
     @Nonnull
-    public final Optional<RangeConstraint<?>> getRangeConstraint() {
+    public final Optional<RangeConstraint<N>> getRangeConstraint() {
         return Optional.ofNullable(rangeConstraint);
     }
 }

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/CompatUtils.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/CompatUtils.java
index db8604d757c32d4b8898bdddade02b26c2db8825..bdf41b76cdcac72a1d0290a798613f643e643e57 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/CompatUtils.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/CompatUtils.java
@@ -23,7 +23,6 @@ import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.LengthRestrictedTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
@@ -195,13 +194,13 @@ public final class CompatUtils {
         return type;
     }
 
-    private static <T extends RangeRestrictedTypeDefinition<T>> T baseTypeIfNotConstrained(final T type) {
+    private static <T extends RangeRestrictedTypeDefinition<T, ?>> T baseTypeIfNotConstrained(final T type) {
         return baseTypeIfNotConstrained(type, type.getBaseType());
     }
 
-    private static <T extends RangeRestrictedTypeDefinition<T>> T baseTypeIfNotConstrained(final T type,
+    private static <T extends RangeRestrictedTypeDefinition<T, ?>> T baseTypeIfNotConstrained(final T type,
             final T base) {
-        final Optional<RangeConstraint<?>> optConstraint = type.getRangeConstraint();
+        final Optional<?> optConstraint = type.getRangeConstraint();
         if (!optConstraint.isPresent()) {
             return base;
         }

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DecimalTypeBuilder.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DecimalTypeBuilder.java
index f71cdf10a902e372b7b81ceae6b0519076b4f274..fbb7ca60d4cdc79b22461b33c542758428ff20a1 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DecimalTypeBuilder.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DecimalTypeBuilder.java
@@ -8,10 +8,11 @@
 package org.opendaylight.yangtools.yang.model.util.type;
 
 import com.google.common.base.Preconditions;
+import java.math.BigDecimal;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
 
-public final class DecimalTypeBuilder extends RangeRestrictedTypeBuilder<DecimalTypeDefinition> {
+public final class DecimalTypeBuilder extends RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> {
     private Integer fractionDigits;
 
     DecimalTypeBuilder(final SchemaPath path) {

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedDecimalType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedDecimalType.java
index 80a5a6b21c997b54a2897e4c8cec6e93148959f9..713872f8e100ac0a7387c90acecdc225848682be 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedDecimalType.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedDecimalType.java
@@ -7,13 +7,14 @@
  */
 package org.opendaylight.yangtools.yang.model.util.type;
 
+import java.math.BigDecimal;
 import java.util.Collection;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
 
-final class DerivedDecimalType extends AbstractRangeRestrictedDerivedType<DecimalTypeDefinition>
+final class DerivedDecimalType extends AbstractRangeRestrictedDerivedType<DecimalTypeDefinition, BigDecimal>
         implements DecimalTypeDefinition {
     DerivedDecimalType(final DecimalTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
         final String description, final String reference, final Status status, final String units,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt16Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt16Type.java
index ac9e54f06eaf6db0bd612249820975ec602c8cda..18129cfb228aebd41341748ad77b9166295c9592 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt16Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt16Type.java
@@ -13,7 +13,7 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
 
-final class DerivedInt16Type extends AbstractRangeRestrictedDerivedType<Int16TypeDefinition>
+final class DerivedInt16Type extends AbstractRangeRestrictedDerivedType<Int16TypeDefinition, Short>
         implements Int16TypeDefinition {
     DerivedInt16Type(final Int16TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
             final String description, final String reference, final Status status, final String units,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt32Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt32Type.java
index 08a5f866ea8cde55a66b121680ec6703c0d3732d..43172b1a7765565ae2ccf3033ada30b5a3e4cdaf 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt32Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt32Type.java
@@ -13,7 +13,7 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
 
-final class DerivedInt32Type extends AbstractRangeRestrictedDerivedType<Int32TypeDefinition>
+final class DerivedInt32Type extends AbstractRangeRestrictedDerivedType<Int32TypeDefinition, Integer>
         implements Int32TypeDefinition {
     DerivedInt32Type(final Int32TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
             final String description, final String reference, final Status status, final String units,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt64Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt64Type.java
index cacda5902585414005b0727f48c47a5bdfbf1407..2828a3b28479a740152b9789b1b0cfbcbe644f8e 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt64Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt64Type.java
@@ -13,7 +13,7 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
 
-final class DerivedInt64Type extends AbstractRangeRestrictedDerivedType<Int64TypeDefinition>
+final class DerivedInt64Type extends AbstractRangeRestrictedDerivedType<Int64TypeDefinition, Long>
         implements Int64TypeDefinition {
     DerivedInt64Type(final Int64TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
             final String description, final String reference, final Status status, final String units,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt8Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt8Type.java
index e8a6d8b1efe66000017e5d4e85c07caaf2615747..f811bbf915528fc9e5986a182f7cc05d745d8b76 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt8Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedInt8Type.java
@@ -13,7 +13,7 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
 
-final class DerivedInt8Type extends AbstractRangeRestrictedDerivedType<Int8TypeDefinition>
+final class DerivedInt8Type extends AbstractRangeRestrictedDerivedType<Int8TypeDefinition, Byte>
         implements Int8TypeDefinition {
     DerivedInt8Type(final Int8TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
             final String description, final String reference, final Status status, final String units,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint16Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint16Type.java
index 60e067ff8ceb89da26d207dc80345d33187da779..fe2c2c42dea58918c1735a6e57278f96c4082df8 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint16Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint16Type.java
@@ -13,7 +13,7 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
 
-final class DerivedUint16Type extends AbstractRangeRestrictedDerivedType<Uint16TypeDefinition>
+final class DerivedUint16Type extends AbstractRangeRestrictedDerivedType<Uint16TypeDefinition, Integer>
         implements Uint16TypeDefinition {
 
     DerivedUint16Type(final Uint16TypeDefinition baseType, final SchemaPath path,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint32Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint32Type.java
index 0d49a421dade72e5361716335fb9fa35b31d5993..2c608811a46396c3eac55ac2c2278326aaae9d85 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint32Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint32Type.java
@@ -13,7 +13,7 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
 
-final class DerivedUint32Type extends AbstractRangeRestrictedDerivedType<Uint32TypeDefinition>
+final class DerivedUint32Type extends AbstractRangeRestrictedDerivedType<Uint32TypeDefinition, Long>
         implements Uint32TypeDefinition {
 
     DerivedUint32Type(final Uint32TypeDefinition baseType, final SchemaPath path,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint64Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint64Type.java
index 2ec81b63d2949c7e9b86b2331b95663ca773aa7c..e9ff61f49d63d6b767832d6ff18a339c92a5cbd5 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint64Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint64Type.java
@@ -7,13 +7,14 @@
  */
 package org.opendaylight.yangtools.yang.model.util.type;
 
+import java.math.BigInteger;
 import java.util.Collection;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
 
-final class DerivedUint64Type extends AbstractRangeRestrictedDerivedType<Uint64TypeDefinition>
+final class DerivedUint64Type extends AbstractRangeRestrictedDerivedType<Uint64TypeDefinition, BigInteger>
         implements Uint64TypeDefinition {
 
     DerivedUint64Type(final Uint64TypeDefinition baseType, final SchemaPath path,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint8Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint8Type.java
index d1b6f11305c66d7160b419e3931d269226c0e993..11b8629f4be5ebc137e6125ecdd09e63ab8e1c87 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint8Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedUint8Type.java
@@ -13,7 +13,7 @@ import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
 
-final class DerivedUint8Type extends AbstractRangeRestrictedDerivedType<Uint8TypeDefinition>
+final class DerivedUint8Type extends AbstractRangeRestrictedDerivedType<Uint8TypeDefinition, Short>
         implements Uint8TypeDefinition {
 
     DerivedUint8Type(final Uint8TypeDefinition baseType, final SchemaPath path,

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RangeRestrictedTypeBuilder.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RangeRestrictedTypeBuilder.java
index ab15278af18514b5ed8dd35ab69e7bbce01651e0..b1565f6e417860d11caf8a45726e67a6728ae4c3 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RangeRestrictedTypeBuilder.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RangeRestrictedTypeBuilder.java
@@ -19,7 +19,6 @@ import com.google.common.collect.Range;
 import com.google.common.collect.RangeSet;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 import java.util.function.Function;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
@@ -29,8 +28,8 @@ import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
 
-public abstract class RangeRestrictedTypeBuilder<T extends RangeRestrictedTypeDefinition<T>>
-        extends AbstractRestrictedTypeBuilder<T> {
+public abstract class RangeRestrictedTypeBuilder<T extends RangeRestrictedTypeDefinition<T, N>,
+        N extends Number & Comparable<N>> extends AbstractRestrictedTypeBuilder<T> {
     private ConstraintMetaDefinition constraint;
     private List<ValueRange> ranges;
 
@@ -47,58 +46,32 @@ public abstract class RangeRestrictedTypeBuilder<T extends RangeRestrictedTypeDe
         touch();
     }
 
-    final <C extends Number & Comparable<C>> RangeConstraint<C> calculateRangeConstraint(
-            final RangeConstraint<C> baseRangeConstraint) {
+    final RangeConstraint<N> calculateRangeConstraint(final RangeConstraint<N> baseRangeConstraint) {
         if (ranges == null) {
             return baseRangeConstraint;
         }
 
         // Run through alternatives and resolve them against the base type
-        final RangeSet<C> baseRangeSet = (RangeSet<C>) baseRangeConstraint.getAllowedRanges();
+        final RangeSet<N> baseRangeSet = baseRangeConstraint.getAllowedRanges();
         Verify.verify(!baseRangeSet.isEmpty(), "Base type %s does not define constraints", getBaseType());
 
-        final Range<? extends C> baseRange = baseRangeSet.span();
+        final Range<N> baseRange = baseRangeSet.span();
         final List<ValueRange> resolvedRanges = ensureResolvedRanges(ranges, baseRange);
 
         // Next up, ensure the of boundaries match base constraints
-        final RangeSet<C> typedRanges = ensureTypedRanges(resolvedRanges, baseRange.lowerEndpoint().getClass());
+        final RangeSet<N> typedRanges = ensureTypedRanges(resolvedRanges, baseRange.lowerEndpoint().getClass());
 
         // Now verify if new ranges are strict subset of base ranges
         if (!baseRangeSet.enclosesAll(typedRanges)) {
             throw new InvalidRangeConstraintException(typedRanges,
-                "Range constraints %s is not a subset of parent constraints %s", typedRanges, baseRangeSet);
+                "Range constraint %s is not a subset of parent constraint %s", typedRanges, baseRangeSet);
         }
 
-        return new RangeConstraint<C>() {
-            @Override
-            public Optional<String> getErrorAppTag() {
-                return constraint.getErrorAppTag();
-            }
-
-            @Override
-            public Optional<String> getErrorMessage() {
-                return constraint.getErrorMessage();
-            }
-
-            @Override
-            public Optional<String> getDescription() {
-                return constraint.getDescription();
-            }
-
-            @Override
-            public Optional<String> getReference() {
-                return constraint.getReference();
-            }
-
-            @Override
-            public RangeSet<? extends C> getAllowedRanges() {
-                return typedRanges;
-            }
-        };
+        return new ResolvedRangeConstraint<>(constraint, typedRanges);
     }
 
     private static <C extends Number & Comparable<C>> List<ValueRange> ensureResolvedRanges(
-            final List<ValueRange> unresolved, final Range<? extends C> baseRange) {
+            final List<ValueRange> unresolved, final Range<C> baseRange) {
         // First check if we need to resolve anything at all
         for (ValueRange c : unresolved) {
             if (c.lowerBound() instanceof UnresolvedNumber || c.upperBound() instanceof UnresolvedNumber) {
@@ -111,18 +84,18 @@ public abstract class RangeRestrictedTypeBuilder<T extends RangeRestrictedTypeDe
     }
 
     private static <T extends Number & Comparable<T>> List<ValueRange> resolveRanges(final List<ValueRange> unresolved,
-            final Range<? extends T> baseRange) {
+            final Range<T> baseRange) {
         final List<ValueRange> ret = new ArrayList<>(unresolved.size());
         for (ValueRange range : unresolved) {
             final Number min = range.lowerBound();
             final Number max = range.upperBound();
 
             if (max instanceof UnresolvedNumber || min instanceof UnresolvedNumber) {
-                final Number rMin = min instanceof UnresolvedNumber
+                final @NonNull Number rMin = min instanceof UnresolvedNumber
                         ?  ((UnresolvedNumber)min).resolveRange(baseRange) : min;
-                final Number rMax = max instanceof UnresolvedNumber
+                final @NonNull Number rMax = max instanceof UnresolvedNumber
                         ?  ((UnresolvedNumber)max).resolveRange(baseRange) : max;
-                ret.add(ValueRange.of((@NonNull Number)rMin, (@NonNull Number)rMax));
+                ret.add(ValueRange.of(rMin, rMax));
             } else {
                 ret.add(range);
             }
@@ -131,6 +104,7 @@ public abstract class RangeRestrictedTypeBuilder<T extends RangeRestrictedTypeDe
         return ret;
     }
 
+    @SuppressWarnings("unchecked")
     private static <T extends Number & Comparable<T>> RangeSet<T> ensureTypedRanges(final List<ValueRange> ranges,
             final Class<? extends Number> clazz) {
         final Builder<T> builder = ImmutableRangeSet.builder();
@@ -145,6 +119,7 @@ public abstract class RangeRestrictedTypeBuilder<T extends RangeRestrictedTypeDe
         return builder.build();
     }
 
+    @SuppressWarnings("unchecked")
     private static <T extends Number & Comparable<T>> RangeSet<T> typedRanges(final List<ValueRange> ranges,
             final Class<? extends Number> clazz) {
         final Function<Number, ? extends Number> function = NumberUtil.converterTo(clazz);

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RangeRestrictedTypeBuilderWithBase.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RangeRestrictedTypeBuilderWithBase.java
index 8492e94f230934bda5878b059b4e5a8c7ede2413..5f8e1fdb0be613e6fcb8f793b7f7e51798994ffd 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RangeRestrictedTypeBuilderWithBase.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RangeRestrictedTypeBuilderWithBase.java
@@ -13,8 +13,8 @@ import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
 
-abstract class RangeRestrictedTypeBuilderWithBase<T extends RangeRestrictedTypeDefinition<T>>
-        extends RangeRestrictedTypeBuilder<T> {
+abstract class RangeRestrictedTypeBuilderWithBase<T extends RangeRestrictedTypeDefinition<T, N>,
+        N extends Number & Comparable<N>> extends RangeRestrictedTypeBuilder<T, N> {
 
     RangeRestrictedTypeBuilderWithBase(final T baseType, final SchemaPath path) {
         super(requireNonNull(baseType), path);
@@ -25,5 +25,5 @@ abstract class RangeRestrictedTypeBuilderWithBase<T extends RangeRestrictedTypeD
         return buildType(calculateRangeConstraint(getBaseType().getRangeConstraint().get()));
     }
 
-    abstract T buildType(RangeConstraint<?> rangeConstraints);
+    abstract T buildType(RangeConstraint<N> rangeConstraints);
 }

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ResolvedRangeConstraint.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ResolvedRangeConstraint.java
index f74cf95ebf4d3e61baac49c9d0c31fedb7ec0d58..57d66289390d653c62095bf34548d75950a58876 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ResolvedRangeConstraint.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ResolvedRangeConstraint.java
@@ -46,7 +46,7 @@ final class ResolvedRangeConstraint<T extends Number & Comparable<T>> implements
     }
 
     @Override
-    public RangeSet<? extends T> getAllowedRanges() {
+    public RangeSet<T> getAllowedRanges() {
         return ranges;
     }
 }

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedDecimalType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedDecimalType.java
index c587ed47689fc5070a41920c74459e733e22d498..d5a0e78f0dcc483028489ccf19a6a9cb581da03d 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedDecimalType.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedDecimalType.java
@@ -7,6 +7,7 @@
  */
 package org.opendaylight.yangtools.yang.model.util.type;
 
+import java.math.BigDecimal;
 import java.util.Collection;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@@ -14,10 +15,11 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 
-final class RestrictedDecimalType extends AbstractRangeRestrictedType<DecimalTypeDefinition>
+final class RestrictedDecimalType extends AbstractRangeRestrictedType<DecimalTypeDefinition, BigDecimal>
         implements DecimalTypeDefinition {
     RestrictedDecimalType(final DecimalTypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes,
+        final @Nullable RangeConstraint<BigDecimal> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt16Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt16Type.java
index ff8b65166786bdfd431516001140ba6ad0f005a8..4b45d03fe0af3f7bb1ffec9d9228940691910e79 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt16Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt16Type.java
@@ -14,10 +14,11 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 
-final class RestrictedInt16Type extends AbstractRangeRestrictedType<Int16TypeDefinition>
+final class RestrictedInt16Type extends AbstractRangeRestrictedType<Int16TypeDefinition, Short>
         implements Int16TypeDefinition {
     RestrictedInt16Type(final Int16TypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes,
+        final @Nullable RangeConstraint<Short> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt32Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt32Type.java
index e57b4cc21e553f52516da2da3fa8412c22c942f2..b54a4569d389f9c6320ed5f72695cfb9556b43ca 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt32Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt32Type.java
@@ -14,10 +14,11 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 
-final class RestrictedInt32Type extends AbstractRangeRestrictedType<Int32TypeDefinition>
+final class RestrictedInt32Type extends AbstractRangeRestrictedType<Int32TypeDefinition, Integer>
         implements Int32TypeDefinition {
     RestrictedInt32Type(final Int32TypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes,
+        final @Nullable RangeConstraint<Integer> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt64Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt64Type.java
index 07081ec9bca7000438b2bb481abb7894550f5cea..ed9f410f0177e1228805fafb0696fad115661441 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt64Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt64Type.java
@@ -14,10 +14,10 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 
-final class RestrictedInt64Type extends AbstractRangeRestrictedType<Int64TypeDefinition>
+final class RestrictedInt64Type extends AbstractRangeRestrictedType<Int64TypeDefinition, Long>
         implements Int64TypeDefinition {
     RestrictedInt64Type(final Int64TypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<Long> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt8Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt8Type.java
index cb6ec1814384efa013eb63a9a70d7a08e3656152..01183d2959d4cf2dea1a116605e56c556012c92c 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt8Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedInt8Type.java
@@ -14,9 +14,10 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 
-final class RestrictedInt8Type extends AbstractRangeRestrictedType<Int8TypeDefinition> implements Int8TypeDefinition {
+final class RestrictedInt8Type extends AbstractRangeRestrictedType<Int8TypeDefinition, Byte>
+        implements Int8TypeDefinition {
     RestrictedInt8Type(final Int8TypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<Byte> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java
index b539ba4d2fdf6cfa7eaf8cf05b7a97ec3f4290c2..439231b8eb07160ae7bf353bafbe7c10487b037e 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java
@@ -8,6 +8,8 @@
 package org.opendaylight.yangtools.yang.model.util.type;
 
 import com.google.common.annotations.Beta;
+import java.math.BigDecimal;
+import java.math.BigInteger;
 import javax.annotation.Nonnull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@@ -105,11 +107,11 @@ public final class RestrictedTypes {
         };
     }
 
-    public static RangeRestrictedTypeBuilder<DecimalTypeDefinition> newDecima64Builder(
+    public static RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> newDecima64Builder(
             final DecimalTypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<DecimalTypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<DecimalTypeDefinition, BigDecimal>(baseType, path) {
             @Override
-            DecimalTypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            DecimalTypeDefinition buildType(final RangeConstraint<BigDecimal> rangeConstraint) {
                 return new RestrictedDecimalType(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
@@ -159,41 +161,41 @@ public final class RestrictedTypes {
         };
     }
 
-    public static RangeRestrictedTypeBuilder<Int8TypeDefinition> newInt8Builder(
+    public static RangeRestrictedTypeBuilder<Int8TypeDefinition, Byte> newInt8Builder(
             final Int8TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Int8TypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<Int8TypeDefinition, Byte>(baseType, path) {
             @Override
-            Int8TypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            Int8TypeDefinition buildType(final RangeConstraint<Byte> rangeConstraint) {
                 return new RestrictedInt8Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
-    public static RangeRestrictedTypeBuilder<Int16TypeDefinition> newInt16Builder(
+    public static RangeRestrictedTypeBuilder<Int16TypeDefinition, Short> newInt16Builder(
             final Int16TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Int16TypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<Int16TypeDefinition, Short>(baseType, path) {
             @Override
-            Int16TypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            Int16TypeDefinition buildType(final RangeConstraint<Short> rangeConstraint) {
                 return new RestrictedInt16Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
-    public static RangeRestrictedTypeBuilder<Int32TypeDefinition> newInt32Builder(
+    public static RangeRestrictedTypeBuilder<Int32TypeDefinition, Integer> newInt32Builder(
             final Int32TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Int32TypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<Int32TypeDefinition, Integer>(baseType, path) {
             @Override
-            Int32TypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            Int32TypeDefinition buildType(final RangeConstraint<Integer> rangeConstraint) {
                 return new RestrictedInt32Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
-    public static RangeRestrictedTypeBuilder<Int64TypeDefinition> newInt64Builder(
+    public static RangeRestrictedTypeBuilder<Int64TypeDefinition, Long> newInt64Builder(
             final Int64TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Int64TypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<Int64TypeDefinition, Long>(baseType, path) {
             @Override
-            Int64TypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            Int64TypeDefinition buildType(final RangeConstraint<Long> rangeConstraint) {
                 return new RestrictedInt64Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
@@ -213,41 +215,41 @@ public final class RestrictedTypes {
         };
     }
 
-    public static RangeRestrictedTypeBuilder<Uint8TypeDefinition> newUint8Builder(
+    public static RangeRestrictedTypeBuilder<Uint8TypeDefinition, Short> newUint8Builder(
             final Uint8TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Uint8TypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<Uint8TypeDefinition, Short>(baseType, path) {
             @Override
-            Uint8TypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            Uint8TypeDefinition buildType(final RangeConstraint<Short> rangeConstraint) {
                 return new RestrictedUint8Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
-    public static RangeRestrictedTypeBuilder<Uint16TypeDefinition> newUint16Builder(
+    public static RangeRestrictedTypeBuilder<Uint16TypeDefinition, Integer> newUint16Builder(
             final Uint16TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Uint16TypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<Uint16TypeDefinition, Integer>(baseType, path) {
             @Override
-            Uint16TypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            Uint16TypeDefinition buildType(final RangeConstraint<Integer> rangeConstraint) {
                 return new RestrictedUint16Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
-    public static RangeRestrictedTypeBuilder<Uint32TypeDefinition> newUint32Builder(
+    public static RangeRestrictedTypeBuilder<Uint32TypeDefinition, Long> newUint32Builder(
             final Uint32TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Uint32TypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<Uint32TypeDefinition, Long>(baseType, path) {
             @Override
-            Uint32TypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            Uint32TypeDefinition buildType(final RangeConstraint<Long> rangeConstraint) {
                 return new RestrictedUint32Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
-    public static RangeRestrictedTypeBuilder<Uint64TypeDefinition> newUint64Builder(
+    public static RangeRestrictedTypeBuilder<Uint64TypeDefinition, BigInteger> newUint64Builder(
             final Uint64TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Uint64TypeDefinition>(baseType, path) {
+        return new RangeRestrictedTypeBuilderWithBase<Uint64TypeDefinition, BigInteger>(baseType, path) {
             @Override
-            Uint64TypeDefinition buildType(final RangeConstraint<?> rangeConstraint) {
+            Uint64TypeDefinition buildType(final RangeConstraint<BigInteger> rangeConstraint) {
                 return new RestrictedUint64Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint16Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint16Type.java
index 3352a9ce98a039a5680ffe5d0ca9dbd4f2600e8e..561eaa288ede0151c5261059897295a952e6aa55 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint16Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint16Type.java
@@ -14,11 +14,12 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
 
-final class RestrictedUint16Type extends AbstractRangeRestrictedType<Uint16TypeDefinition>
+final class RestrictedUint16Type extends AbstractRangeRestrictedType<Uint16TypeDefinition, Integer>
         implements Uint16TypeDefinition {
 
     RestrictedUint16Type(final Uint16TypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes,
+        final @Nullable RangeConstraint<Integer> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint32Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint32Type.java
index 8513d7329b4e563292a434983a44a89fa516fcc6..e167223cc27b5767539c76da4133947daac4c95e 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint32Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint32Type.java
@@ -14,11 +14,12 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
 
-final class RestrictedUint32Type extends AbstractRangeRestrictedType<Uint32TypeDefinition>
+final class RestrictedUint32Type extends AbstractRangeRestrictedType<Uint32TypeDefinition, Long>
         implements Uint32TypeDefinition {
 
     RestrictedUint32Type(final Uint32TypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes,
+        final @Nullable RangeConstraint<Long> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint64Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint64Type.java
index 7be6a95bd7d0b394b3a954a0befe828ea4e50a9c..fcc12aac0ca90314a70c0458fadb8177df17226b 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint64Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint64Type.java
@@ -7,6 +7,7 @@
  */
 package org.opendaylight.yangtools.yang.model.util.type;
 
+import java.math.BigInteger;
 import java.util.Collection;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@@ -14,11 +15,12 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
 
-final class RestrictedUint64Type extends AbstractRangeRestrictedType<Uint64TypeDefinition>
+final class RestrictedUint64Type extends AbstractRangeRestrictedType<Uint64TypeDefinition, BigInteger>
         implements Uint64TypeDefinition {
 
     RestrictedUint64Type(final Uint64TypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes,
+        final @Nullable RangeConstraint<BigInteger> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint8Type.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint8Type.java
index 7d28055fa4f3623d926765494b15ae0da8081716..ee84fb4c5cf6d2847ca7a4ba76c16a7ba37c11a5 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint8Type.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedUint8Type.java
@@ -14,11 +14,12 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
 
-final class RestrictedUint8Type extends AbstractRangeRestrictedType<Uint8TypeDefinition>
+final class RestrictedUint8Type extends AbstractRangeRestrictedType<Uint8TypeDefinition, Short>
         implements Uint8TypeDefinition {
 
     RestrictedUint8Type(final Uint8TypeDefinition baseType, final SchemaPath path,
-        final Collection<UnknownSchemaNode> unknownSchemaNodes, final @Nullable RangeConstraint<?> rangeConstraint) {
+        final Collection<UnknownSchemaNode> unknownSchemaNodes,
+        final @Nullable RangeConstraint<Short> rangeConstraint) {
         super(baseType, path, unknownSchemaNodes, rangeConstraint);
     }
 

diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/type/TypeTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/type/TypeTest.java
index 667e8c31bde8565cd4579f792bb6db9461020f1b..2fd472c24cbc9d61078725f0fa6536950657e9e1 100644 (file)
--- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/type/TypeTest.java
+++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/type/TypeTest.java
@@ -428,7 +428,7 @@ public class TypeTest {
         assertNotNull(typeDefinition);
 
         final Int8TypeDefinition integerTypeDefinition8 = BaseTypes.int8Type();
-        final RangeRestrictedTypeBuilder<?> rangeRestrictedTypeBuilder = RestrictedTypes.newInt8Builder(
+        final RangeRestrictedTypeBuilder<?, ?> rangeRestrictedTypeBuilder = RestrictedTypes.newInt8Builder(
             integerTypeDefinition8, SCHEMA_PATH);
         rangeRestrictedTypeBuilder.setRangeConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
         final TypeDefinition<?> typeDefinition1 = rangeRestrictedTypeBuilder.buildType();

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/DecimalTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/DecimalTypeEffectiveStatementImpl.java
index c0b64581c165231456cb3275c6032b7b20664239..411542c446e8276f2ea0c585dd49e9159418a004 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/DecimalTypeEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/DecimalTypeEffectiveStatementImpl.java
@@ -8,6 +8,7 @@
 
 package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
 
+import java.math.BigDecimal;
 import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
@@ -31,7 +32,7 @@ public final class DecimalTypeEffectiveStatementImpl extends DeclaredEffectiveSt
             final DecimalTypeDefinition baseType) {
         super(ctx);
 
-        final RangeRestrictedTypeBuilder<DecimalTypeDefinition> builder =
+        final RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> builder =
                 RestrictedTypes.newDecima64Builder(baseType, TypeUtils.typeEffectiveSchemaPath(ctx));
 
         for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerTypeEffectiveStatementImpl.java
index b35d76330bccd8158e5cd8a4a03f75bdc5d297ef..8ca27b4010672a6fa76dbfe9eab4a08983939635 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerTypeEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IntegerTypeEffectiveStatementImpl.java
@@ -26,14 +26,15 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl;
 
-public final class IntegerTypeEffectiveStatementImpl<T extends IntegerTypeDefinition<?, T>> extends
-        DeclaredEffectiveStatementBase<String, TypeStatement> implements TypeEffectiveStatement<TypeStatement> {
+public final class IntegerTypeEffectiveStatementImpl<T extends IntegerTypeDefinition<N, T>,
+        N extends Number & Comparable<N>> extends DeclaredEffectiveStatementBase<String, TypeStatement>
+        implements TypeEffectiveStatement<TypeStatement> {
 
     private final T typeDefinition;
 
     private IntegerTypeEffectiveStatementImpl(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
-            final RangeRestrictedTypeBuilder<T> builder) {
+            final RangeRestrictedTypeBuilder<T, N> builder) {
         super(ctx);
 
         for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
@@ -54,28 +55,28 @@ public final class IntegerTypeEffectiveStatementImpl<T extends IntegerTypeDefini
         }
     }
 
-    public static IntegerTypeEffectiveStatementImpl<Int8TypeDefinition> create(
+    public static IntegerTypeEffectiveStatementImpl<Int8TypeDefinition, Byte> create(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
             final Int8TypeDefinition baseType) {
         return new IntegerTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newInt8Builder(baseType,
             TypeUtils.typeEffectiveSchemaPath(ctx)));
     }
 
-    public static IntegerTypeEffectiveStatementImpl<Int16TypeDefinition> create(
+    public static IntegerTypeEffectiveStatementImpl<Int16TypeDefinition, Short> create(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
             final Int16TypeDefinition baseType) {
         return new IntegerTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newInt16Builder(baseType,
             TypeUtils.typeEffectiveSchemaPath(ctx)));
     }
 
-    public static IntegerTypeEffectiveStatementImpl<Int32TypeDefinition> create(
+    public static IntegerTypeEffectiveStatementImpl<Int32TypeDefinition, Integer> create(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
             final Int32TypeDefinition baseType) {
         return new IntegerTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newInt32Builder(baseType,
             TypeUtils.typeEffectiveSchemaPath(ctx)));
     }
 
-    public static IntegerTypeEffectiveStatementImpl<Int64TypeDefinition> create(
+    public static IntegerTypeEffectiveStatementImpl<Int64TypeDefinition, Long> create(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
             final Int64TypeDefinition baseType) {
         return new IntegerTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newInt64Builder(baseType,

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/UnsignedIntegerTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/UnsignedIntegerTypeEffectiveStatementImpl.java
index 7f207894ecc76412a998d81d21ccb96e6b7c8ea1..c17ebb178924da85ad5172f1ff0b3c11af15dd1f 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/UnsignedIntegerTypeEffectiveStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/UnsignedIntegerTypeEffectiveStatementImpl.java
@@ -8,6 +8,7 @@
 
 package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
 
+import java.math.BigInteger;
 import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
@@ -24,14 +25,15 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl;
 
-public final class UnsignedIntegerTypeEffectiveStatementImpl<T extends UnsignedIntegerTypeDefinition<?, T>> extends
-        DeclaredEffectiveStatementBase<String, TypeStatement> implements TypeEffectiveStatement<TypeStatement> {
+public final class UnsignedIntegerTypeEffectiveStatementImpl<T extends UnsignedIntegerTypeDefinition<N, T>,
+        N extends Number & Comparable<N>> extends DeclaredEffectiveStatementBase<String, TypeStatement>
+        implements TypeEffectiveStatement<TypeStatement> {
 
     private final T typeDefinition;
 
     private UnsignedIntegerTypeEffectiveStatementImpl(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
-            final RangeRestrictedTypeBuilder<T> builder) {
+            final RangeRestrictedTypeBuilder<T, N> builder) {
         super(ctx);
 
         for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
@@ -47,28 +49,28 @@ public final class UnsignedIntegerTypeEffectiveStatementImpl<T extends UnsignedI
         typeDefinition = builder.build();
     }
 
-    public static UnsignedIntegerTypeEffectiveStatementImpl<Uint8TypeDefinition> create(
+    public static UnsignedIntegerTypeEffectiveStatementImpl<Uint8TypeDefinition, Short> create(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
             final Uint8TypeDefinition baseType) {
         return new UnsignedIntegerTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newUint8Builder(baseType,
             TypeUtils.typeEffectiveSchemaPath(ctx)));
     }
 
-    public static UnsignedIntegerTypeEffectiveStatementImpl<Uint16TypeDefinition> create(
+    public static UnsignedIntegerTypeEffectiveStatementImpl<Uint16TypeDefinition, Integer> create(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
             final Uint16TypeDefinition baseType) {
         return new UnsignedIntegerTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newUint16Builder(baseType,
             TypeUtils.typeEffectiveSchemaPath(ctx)));
     }
 
-    public static UnsignedIntegerTypeEffectiveStatementImpl<Uint32TypeDefinition> create(
+    public static UnsignedIntegerTypeEffectiveStatementImpl<Uint32TypeDefinition, Long> create(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
             final Uint32TypeDefinition baseType) {
         return new UnsignedIntegerTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newUint32Builder(baseType,
             TypeUtils.typeEffectiveSchemaPath(ctx)));
     }
 
-    public static UnsignedIntegerTypeEffectiveStatementImpl<Uint64TypeDefinition> create(
+    public static UnsignedIntegerTypeEffectiveStatementImpl<Uint64TypeDefinition, BigInteger> create(
             final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
             final Uint64TypeDefinition baseType) {
         return new UnsignedIntegerTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newUint64Builder(baseType,
@@ -77,7 +79,7 @@ public final class UnsignedIntegerTypeEffectiveStatementImpl<T extends UnsignedI
 
     @Nonnull
     @Override
-    public UnsignedIntegerTypeDefinition getTypeDefinition() {
+    public T getTypeDefinition() {
         return typeDefinition;
     }
 }