X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Futil%2FTypeConstraints.java;h=958d5f280b8e4890735eaa2f7014d23c14719b92;hb=42abb28b99a02f9580f4676ce5c315628e5bcd24;hp=8575c4ec2ed797b95093d5d940b55337f5f54b63;hpb=5c1f875f69e35248aa4115c429bd962160beeef4;p=yangtools.git

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/TypeConstraints.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/TypeConstraints.java
index 8575c4ec2e..958d5f280b 100644
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/TypeConstraints.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/TypeConstraints.java
@@ -7,10 +7,11 @@
  */
 package org.opendaylight.yangtools.yang.parser.util;
 
+import com.google.common.base.Optional;
+import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-
 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
@@ -18,24 +19,23 @@ import org.opendaylight.yangtools.yang.model.util.BaseConstraints;
 
 /**
  * Holder object for holding YANG type constraints.
+ *
+ * @deprecated Pre-Beryllium implementation, scheduled for removal.
  */
+@Deprecated
 public final class TypeConstraints {
     private final String moduleName;
     private final int line;
-    private final List<List<RangeConstraint>> ranges = new ArrayList<List<RangeConstraint>>();
-    private final List<List<LengthConstraint>> lengths = new ArrayList<List<LengthConstraint>>();
-    private final List<List<PatternConstraint>> patterns = new ArrayList<List<PatternConstraint>>();
-    private final List<Integer> fractionDigits = new ArrayList<Integer>();
+    private final List<List<RangeConstraint>> ranges = new ArrayList<>();
+    private final List<List<LengthConstraint>> lengths = new ArrayList<>();
+    private final List<List<PatternConstraint>> patterns = new ArrayList<>();
+    private final List<Integer> fractionDigits = new ArrayList<>();
 
     public TypeConstraints(final String moduleName, final int line) {
         this.moduleName = moduleName;
         this.line = line;
     }
 
-    List<List<RangeConstraint>> getAllRanges() {
-        return ranges;
-    }
-
     public List<RangeConstraint> getRange() {
         if (ranges.size() < 2) {
             return Collections.emptyList();
@@ -61,22 +61,27 @@ public final class TypeConstraints {
             if (max instanceof UnknownBoundaryNumber) {
                 max = resolveMaxRange(max);
             }
-            firstRange = BaseConstraints.rangeConstraint(min, max, firstRange.getDescription(),
-                    firstRange.getReference());
+            firstRange = BaseConstraints.newRangeConstraint(min, max,
+                Optional.fromNullable(firstRange.getDescription()),
+                Optional.fromNullable(firstRange.getReference()));
             resolved.set(0, firstRange);
-            lastRange = BaseConstraints.rangeConstraint(min, max, lastRange.getDescription(), lastRange.getReference());
+            lastRange = BaseConstraints.newRangeConstraint(min, max,
+                Optional.fromNullable(lastRange.getDescription()),
+                Optional.fromNullable(lastRange.getReference()));
             resolved.set(resolved.size() - 1, lastRange);
         } else {
             if (min instanceof UnknownBoundaryNumber) {
                 min = resolveMinRange(min);
-                firstRange = BaseConstraints.rangeConstraint(min, firstRange.getMax(), firstRange.getDescription(),
-                        firstRange.getReference());
+                firstRange = BaseConstraints.newRangeConstraint(min, firstRange.getMax(),
+                    Optional.fromNullable(firstRange.getDescription()),
+                    Optional.fromNullable(firstRange.getReference()));
                 resolved.set(0, firstRange);
             }
             if (max instanceof UnknownBoundaryNumber) {
                 max = resolveMaxRange(max);
-                lastRange = BaseConstraints.rangeConstraint(lastRange.getMin(), max, lastRange.getDescription(),
-                        lastRange.getReference());
+                lastRange = BaseConstraints.newRangeConstraint(lastRange.getMin(), max,
+                    Optional.fromNullable(lastRange.getDescription()),
+                    Optional.fromNullable(lastRange.getReference()));
                 resolved.set(resolved.size() - 1, lastRange);
             }
         }
@@ -86,24 +91,26 @@ public final class TypeConstraints {
         return resolved;
     }
 
-    private Number resolveMinRange(Number min) {
+    private Number resolveMinRange(final Number min) {
         int i = 1;
-        while (min instanceof UnknownBoundaryNumber) {
+        Number newMin = min;
+        while (newMin instanceof UnknownBoundaryNumber) {
             final List<RangeConstraint> act = ranges.get(i);
-            min = act.get(0).getMin();
+            newMin = act.get(0).getMin();
             i++;
         }
-        return min;
+        return newMin;
     }
 
-    private Number resolveMaxRange(Number max) {
+    private Number resolveMaxRange(final Number max) {
         int i = 1;
-        while (max instanceof UnknownBoundaryNumber) {
+        Number newMax = max;
+        while (newMax instanceof UnknownBoundaryNumber) {
             final List<RangeConstraint> act = ranges.get(i);
-            max = act.get(act.size() - 1).getMax();
+            newMax = act.get(act.size() - 1).getMax();
             i++;
         }
-        return max;
+        return newMax;
     }
 
     public void addRanges(final List<RangeConstraint> ranges) {
@@ -141,23 +148,27 @@ public final class TypeConstraints {
             if (max instanceof UnknownBoundaryNumber) {
                 max = resolveMaxLength(max);
             }
-            firstLength = BaseConstraints.lengthConstraint(min, max, firstLength.getDescription(),
-                    firstLength.getReference());
+            firstLength = BaseConstraints.newLengthConstraint(min, max,
+                Optional.fromNullable(firstLength.getDescription()),
+                Optional.fromNullable(firstLength.getReference()));
             resolved.set(0, firstLength);
-            lastLength = BaseConstraints.lengthConstraint(min, max, lastLength.getDescription(),
-                    lastLength.getReference());
+            lastLength = BaseConstraints.newLengthConstraint(min, max,
+                Optional.fromNullable(lastLength.getDescription()),
+                Optional.fromNullable(lastLength.getReference()));
             resolved.set(resolved.size() - 1, lastLength);
         } else {
             if (min instanceof UnknownBoundaryNumber) {
                 min = resolveMinLength(min);
-                firstLength = BaseConstraints.lengthConstraint(min, firstLength.getMax(), firstLength.getDescription(),
-                        firstLength.getReference());
+                firstLength = BaseConstraints.newLengthConstraint(min, firstLength.getMax(),
+                    Optional.fromNullable(firstLength.getDescription()),
+                    Optional.fromNullable(firstLength.getReference()));
                 resolved.set(0, firstLength);
             }
             if (max instanceof UnknownBoundaryNumber) {
                 max = resolveMaxLength(max);
-                lastLength = BaseConstraints.lengthConstraint(lastLength.getMin(), max, lastLength.getDescription(),
-                        lastLength.getReference());
+                lastLength = BaseConstraints.newLengthConstraint(lastLength.getMin(), max,
+                    Optional.fromNullable(lastLength.getDescription()),
+                    Optional.fromNullable(lastLength.getReference()));
                 resolved.set(resolved.size() - 1, lastLength);
             }
         }
@@ -168,24 +179,26 @@ public final class TypeConstraints {
         return resolved;
     }
 
-    private Number resolveMinLength(Number min) {
+    private Number resolveMinLength(final Number min) {
         int i = 1;
-        while (min instanceof UnknownBoundaryNumber) {
+        Number newMin = min;
+        while (newMin instanceof UnknownBoundaryNumber) {
             final List<LengthConstraint> act = lengths.get(i);
-            min = act.get(0).getMin();
+            newMin = act.get(0).getMin();
             i++;
         }
-        return min;
+        return newMin;
     }
 
-    private Number resolveMaxLength(Number max) {
+    private Number resolveMaxLength(final Number max) {
         int i = 1;
-        while (max instanceof UnknownBoundaryNumber) {
+        Number newMax = max;
+        while (newMax instanceof UnknownBoundaryNumber) {
             final List<LengthConstraint> act = lengths.get(i);
-            max = act.get(act.size() - 1).getMax();
+            newMax = act.get(act.size() - 1).getMax();
             i++;
         }
-        return max;
+        return newMax;
     }
 
     public void addLengths(final List<LengthConstraint> lengths) {
@@ -195,7 +208,7 @@ public final class TypeConstraints {
     }
 
     public List<PatternConstraint> getPatterns() {
-        if(patterns.isEmpty()) {
+        if (patterns.isEmpty()) {
             return Collections.emptyList();
         }
         return patterns.get(0);
@@ -222,89 +235,61 @@ public final class TypeConstraints {
     }
 
     private void validateRange() {
+        validateRange(getRange());
+    }
+
+    private void validateRange(final List<RangeConstraint> typeRange) {
         if (ranges.size() < 2) {
             return;
         }
-        List<RangeConstraint> typeRange = getRange();
 
         for (RangeConstraint range : typeRange) {
             if (range.getMin() instanceof UnknownBoundaryNumber || range.getMax() instanceof UnknownBoundaryNumber) {
                 throw new YangParseException(moduleName, line, "Unresolved range constraints");
             }
-            final long min = range.getMin().longValue();
-            final long max = range.getMax().longValue();
+            final BigDecimal min = new BigDecimal(range.getMin().toString());
+            final BigDecimal max = new BigDecimal(range.getMax().toString());
 
             List<RangeConstraint> parentRanges = ranges.get(1);
-            boolean check = false;
-            for (RangeConstraint r : parentRanges) {
-                Number parentMinNumber = r.getMin();
-                if (parentMinNumber instanceof UnknownBoundaryNumber) {
-                    parentMinNumber = resolveMinRange(parentMinNumber);
-                }
-                long parentMin = parentMinNumber.longValue();
-
-                Number parentMaxNumber = r.getMax();
-                if (parentMaxNumber instanceof UnknownBoundaryNumber) {
-                    parentMaxNumber = resolveMaxRange(parentMaxNumber);
-                }
-                long parentMax = parentMaxNumber.longValue();
-
-                if (parentMin <= min && parentMax >= max) {
-                    check = true;
-                    break;
-                }
-            }
-            if (!check) {
+            if (!areRangesSubintervalsOfParentRanges(parentRanges, min, max)) {
                 throw new YangParseException(moduleName, line, "Invalid range constraint: <" + min + ", " + max
                         + "> (parent: " + parentRanges + ").");
             }
         }
     }
 
-    private void validateRange(List<RangeConstraint> typeRange) {
-        if (ranges.size() < 2) {
-            return;
-        }
-
-        for (RangeConstraint range : typeRange) {
-            if (range.getMin() instanceof UnknownBoundaryNumber || range.getMax() instanceof UnknownBoundaryNumber) {
-                throw new YangParseException(moduleName, line, "Unresolved range constraints");
+    private boolean areRangesSubintervalsOfParentRanges(final List<RangeConstraint> parentRanges, final BigDecimal min,
+            final BigDecimal max) {
+        boolean check = false;
+        for (RangeConstraint r : parentRanges) {
+            Number parentMinNumber = r.getMin();
+            if (parentMinNumber instanceof UnknownBoundaryNumber) {
+                parentMinNumber = resolveMinRange(parentMinNumber);
             }
-            final long min = range.getMin().longValue();
-            final long max = range.getMax().longValue();
+            BigDecimal parentMin = new BigDecimal(parentMinNumber.toString());
 
-            List<RangeConstraint> parentRanges = ranges.get(1);
-            boolean check = false;
-            for (RangeConstraint r : parentRanges) {
-                Number parentMinNumber = r.getMin();
-                if (parentMinNumber instanceof UnknownBoundaryNumber) {
-                    parentMinNumber = resolveMinRange(parentMinNumber);
-                }
-                long parentMin = parentMinNumber.longValue();
-
-                Number parentMaxNumber = r.getMax();
-                if (parentMaxNumber instanceof UnknownBoundaryNumber) {
-                    parentMaxNumber = resolveMaxRange(parentMaxNumber);
-                }
-                long parentMax = parentMaxNumber.longValue();
-
-                if (parentMin <= min && parentMax >= max) {
-                    check = true;
-                    break;
-                }
+            Number parentMaxNumber = r.getMax();
+            if (parentMaxNumber instanceof UnknownBoundaryNumber) {
+                parentMaxNumber = resolveMaxRange(parentMaxNumber);
             }
-            if (!check) {
-                throw new YangParseException(moduleName, line, "Invalid range constraint: <" + min + ", " + max
-                        + "> (parent: " + parentRanges + ").");
+            BigDecimal parentMax = new BigDecimal(parentMaxNumber.toString());
+
+            if (parentMin.compareTo(min) <= 0 && parentMax.compareTo(max) >= 0) {
+                check = true;
+                break;
             }
         }
+        return check;
     }
 
     private void validateLength() {
+        validateLength(getLength());
+    }
+
+    private void validateLength(final List<LengthConstraint> typeLength) {
         if (lengths.size() < 2) {
             return;
         }
-        List<LengthConstraint> typeLength = getLength();
 
         for (LengthConstraint length : typeLength) {
             if (length.getMin() instanceof UnknownBoundaryNumber || length.getMax() instanceof UnknownBoundaryNumber) {
@@ -314,69 +299,35 @@ public final class TypeConstraints {
             final long max = length.getMax().longValue();
 
             List<LengthConstraint> parentLengths = lengths.get(1);
-            boolean check = false;
-            for (LengthConstraint lc : parentLengths) {
-                Number parentMinNumber = lc.getMin();
-                if (parentMinNumber instanceof UnknownBoundaryNumber) {
-                    parentMinNumber = resolveMinLength(parentMinNumber);
-                }
-                long parentMin = parentMinNumber.longValue();
-
-                Number parentMaxNumber = lc.getMax();
-                if (parentMaxNumber instanceof UnknownBoundaryNumber) {
-                    parentMaxNumber = resolveMaxLength(parentMaxNumber);
-                }
-                long parentMax = parentMaxNumber.longValue();
-
-                if (parentMin <= min && parentMax >= max) {
-                    check = true;
-                    break;
-                }
-            }
-            if (!check) {
+            if (!areLengthRangesSubintervalsOfParentLengthRanges(parentLengths, min, max)) {
                 throw new YangParseException(moduleName, line, "Invalid length constraint: <" + min + ", " + max
                         + "> (parent: " + parentLengths + ").");
             }
         }
     }
 
-    private void validateLength(List<LengthConstraint> typeLength) {
-        if (lengths.size() < 2) {
-            return;
-        }
-
-        for (LengthConstraint length : typeLength) {
-            if (length.getMin() instanceof UnknownBoundaryNumber || length.getMax() instanceof UnknownBoundaryNumber) {
-                throw new YangParseException(moduleName, line, "Unresolved length constraints");
+    private boolean areLengthRangesSubintervalsOfParentLengthRanges(final List<LengthConstraint> parentLengths,
+            final long min, final long max) {
+        boolean check = false;
+        for (LengthConstraint lc : parentLengths) {
+            Number parentMinNumber = lc.getMin();
+            if (parentMinNumber instanceof UnknownBoundaryNumber) {
+                parentMinNumber = resolveMinLength(parentMinNumber);
             }
-            final long min = length.getMin().longValue();
-            final long max = length.getMax().longValue();
+            long parentMin = parentMinNumber.longValue();
 
-            List<LengthConstraint> parentLengths = lengths.get(1);
-            boolean check = false;
-            for (LengthConstraint lc : parentLengths) {
-                Number parentMinNumber = lc.getMin();
-                if (parentMinNumber instanceof UnknownBoundaryNumber) {
-                    parentMinNumber = resolveMinLength(parentMinNumber);
-                }
-                long parentMin = parentMinNumber.longValue();
-
-                Number parentMaxNumber = lc.getMax();
-                if (parentMaxNumber instanceof UnknownBoundaryNumber) {
-                    parentMaxNumber = resolveMaxLength(parentMaxNumber);
-                }
-                long parentMax = parentMaxNumber.longValue();
-
-                if (parentMin <= min && parentMax >= max) {
-                    check = true;
-                    break;
-                }
+            Number parentMaxNumber = lc.getMax();
+            if (parentMaxNumber instanceof UnknownBoundaryNumber) {
+                parentMaxNumber = resolveMaxLength(parentMaxNumber);
             }
-            if (!check) {
-                throw new YangParseException(moduleName, line, "Invalid length constraint: <" + min + ", " + max
-                        + "> (parent: " + parentLengths + ").");
+            long parentMax = parentMaxNumber.longValue();
+
+            if (parentMin <= min && parentMax >= max) {
+                check = true;
+                break;
             }
         }
+        return check;
     }
 
 }