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