opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/util/TypeConstraints.java

   1 /*
   2  * Copyright (c) 2013 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.controller.yang.model.parser.util;
   9
  10 import java.util.ArrayList;
  11 import java.util.Collections;
  12 import java.util.List;
  13
  14 import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
  15 import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
  16 import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
  17 import org.opendaylight.controller.yang.model.util.BaseConstraints;
  18
  19 /**
  20  * Holder object for holding YANG type constraints.
  21  */
  22 public final class TypeConstraints {
  23     private final List<List<RangeConstraint>> ranges = new ArrayList<List<RangeConstraint>>();
  24     private final List<List<LengthConstraint>> lengths = new ArrayList<List<LengthConstraint>>();
  25     private final List<PatternConstraint> patterns = new ArrayList<PatternConstraint>();
  26     private Integer fractionDigits;
  27
  28     List<List<RangeConstraint>> getAllRanges() {
  29         return ranges;
  30     }
  31
  32     public List<RangeConstraint> getRange() {
  33         if(ranges.isEmpty()) {
  34             List<RangeConstraint> result = Collections.emptyList();
  35             return result;
  36         }
  37
  38         List<RangeConstraint> resolved = ranges.get(0);
  39         RangeConstraint firstRange = resolved.get(0);
  40         RangeConstraint lastRange = resolved.get(resolved.size() - 1);
  41         Number min = firstRange.getMin();
  42         Number max = lastRange.getMax();
  43
  44         if (!(min instanceof UnknownBoundaryNumber)
  45                 && !(max instanceof UnknownBoundaryNumber)) {
  46             return resolved;
  47         }
  48
  49         if (firstRange == lastRange) {
  50             if (min instanceof UnknownBoundaryNumber) {
  51                 min = resolveMinRange(min);
  52             }
  53             if (max instanceof UnknownBoundaryNumber) {
  54                 max = resolveMaxRange(max);
  55             }
  56             firstRange = BaseConstraints.rangeConstraint(min, max,
  57                     firstRange.getDescription(), firstRange.getReference());
  58             resolved.set(0, firstRange);
  59             lastRange = BaseConstraints.rangeConstraint(min, max,
  60                     lastRange.getDescription(), lastRange.getReference());
  61             resolved.set(resolved.size() - 1, lastRange);
  62         } else {
  63             if (min instanceof UnknownBoundaryNumber) {
  64                 min = resolveMinRange(min);
  65                 firstRange = BaseConstraints.rangeConstraint(min,
  66                         firstRange.getMax(), firstRange.getDescription(),
  67                         firstRange.getReference());
  68                 resolved.set(0, firstRange);
  69             }
  70             if (max instanceof UnknownBoundaryNumber) {
  71                 max = resolveMaxRange(max);
  72                 lastRange = BaseConstraints.rangeConstraint(lastRange.getMin(),
  73                         max, lastRange.getDescription(),
  74                         lastRange.getReference());
  75                 resolved.set(resolved.size() - 1, lastRange);
  76             }
  77         }
  78         return resolved;
  79     }
  80
  81     private Number resolveMinRange(Number min) {
  82         int i = 1;
  83         while (min instanceof UnknownBoundaryNumber) {
  84             List<RangeConstraint> act = ranges.get(i);
  85             min = act.get(0).getMin();
  86             i++;
  87         }
  88         return min;
  89     }
  90
  91     private Number resolveMaxRange(Number max) {
  92         int i = 1;
  93         while (max instanceof UnknownBoundaryNumber) {
  94             List<RangeConstraint> act = ranges.get(i);
  95             max = act.get(act.size() - 1).getMax();
  96             i++;
  97         }
  98         return max;
  99     }
 100
 101     public void addRanges(List<RangeConstraint> ranges) {
 102         if (ranges != null && ranges.size() > 0) {
 103             this.ranges.add(ranges);
 104         }
 105     }
 106
 107     public List<List<LengthConstraint>> getAllLengths() {
 108         return lengths;
 109     }
 110
 111     public List<LengthConstraint> getLength() {
 112         if(lengths.isEmpty()) {
 113             List<LengthConstraint> result = Collections.emptyList();
 114             return result;
 115         }
 116
 117         List<LengthConstraint> resolved = lengths.get(0);
 118         LengthConstraint firstLength = resolved.get(0);
 119         LengthConstraint lastLength = resolved.get(resolved.size() - 1);
 120         Number min = firstLength.getMin();
 121         Number max = lastLength.getMax();
 122
 123         if (!(min instanceof UnknownBoundaryNumber)
 124                 && !(max instanceof UnknownBoundaryNumber)) {
 125             return resolved;
 126         }
 127
 128         if (firstLength == lastLength) {
 129             if (min instanceof UnknownBoundaryNumber) {
 130                 min = resolveMinLength(min);
 131             }
 132             if (max instanceof UnknownBoundaryNumber) {
 133                 max = resolveMaxLength(max);
 134             }
 135             firstLength = BaseConstraints.lengthConstraint(min, max,
 136                     firstLength.getDescription(), firstLength.getReference());
 137             resolved.set(0, firstLength);
 138             lastLength = BaseConstraints.lengthConstraint(min, max,
 139                     lastLength.getDescription(), lastLength.getReference());
 140             resolved.set(resolved.size() - 1, lastLength);
 141         } else {
 142             if (min instanceof UnknownBoundaryNumber) {
 143                 min = resolveMinLength(min);
 144                 firstLength = BaseConstraints.lengthConstraint(min,
 145                         firstLength.getMax(), firstLength.getDescription(),
 146                         firstLength.getReference());
 147                 resolved.set(0, firstLength);
 148             }
 149             if (max instanceof UnknownBoundaryNumber) {
 150                 max = resolveMaxLength(max);
 151                 lastLength = BaseConstraints.lengthConstraint(
 152                         lastLength.getMin(), max, lastLength.getDescription(),
 153                         lastLength.getReference());
 154                 resolved.set(resolved.size() - 1, lastLength);
 155             }
 156         }
 157         return resolved;
 158     }
 159
 160     private Number resolveMinLength(Number min) {
 161         int i = 1;
 162         while (min instanceof UnknownBoundaryNumber) {
 163             List<LengthConstraint> act = lengths.get(i);
 164             min = act.get(0).getMin();
 165             i++;
 166         }
 167         return min;
 168     }
 169
 170     private Number resolveMaxLength(Number max) {
 171         int i = 1;
 172         while (max instanceof UnknownBoundaryNumber) {
 173             List<LengthConstraint> act = lengths.get(i);
 174             max = act.get(act.size() - 1).getMax();
 175             i++;
 176         }
 177         return max;
 178     }
 179
 180     public void addLengths(List<LengthConstraint> lengths) {
 181         if (lengths != null && lengths.size() > 0) {
 182             this.lengths.add(lengths);
 183         }
 184     }
 185
 186     public List<PatternConstraint> getPatterns() {
 187         return patterns;
 188     }
 189
 190     public void addPatterns(List<PatternConstraint> patterns) {
 191         this.patterns.addAll(patterns);
 192     }
 193
 194     public Integer getFractionDigits() {
 195         return fractionDigits;
 196     }
 197
 198     public void setFractionDigits(Integer fractionDigits) {
 199         if (this.fractionDigits == null) {
 200             this.fractionDigits = fractionDigits;
 201         }
 202     }
 203
 204 }