yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ConstraintsBuilderImpl.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.yangtools.yang.parser.builder.impl;
   9
  10 import com.google.common.collect.ImmutableSet;
  11 import java.util.Collections;
  12 import java.util.HashSet;
  13 import java.util.Objects;
  14 import java.util.Set;
  15 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
  16 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
  17 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
  18 import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
  19 import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
  20
  21 public final class ConstraintsBuilderImpl implements ConstraintsBuilder {
  22     private static final ConstraintDefinitionImpl EMPTY_CONSTRAINT = new ConstraintDefinitionImpl();
  23     private static final ConstraintDefinitionImpl EMPTY_MANDATORY_CONSTRAINT;
  24
  25     static {
  26         ConstraintDefinitionImpl c = new ConstraintDefinitionImpl();
  27         c.setMandatory(true);
  28
  29         EMPTY_MANDATORY_CONSTRAINT = c;
  30     }
  31
  32     private final String moduleName;
  33     private final int line;
  34     private final Set<MustDefinition> mustDefinitions;
  35     private ConstraintDefinitionImpl instance;
  36     private RevisionAwareXPath whenStmt;
  37     private String whenCondition;
  38     private boolean mandatory;
  39     private Integer min;
  40     private Integer max;
  41
  42     public ConstraintsBuilderImpl(final String moduleName, final int line) {
  43         this.moduleName = moduleName;
  44         this.line = line;
  45         mustDefinitions = new HashSet<>();
  46     }
  47
  48     ConstraintsBuilderImpl(final ConstraintsBuilder b) {
  49         this.moduleName = b.getModuleName();
  50         this.line = b.getLine();
  51         mustDefinitions = new HashSet<>(b.getMustDefinitions());
  52         whenCondition = b.getWhenCondition();
  53         mandatory = b.isMandatory();
  54         min = b.getMinElements();
  55         max = b.getMaxElements();
  56     }
  57
  58     ConstraintsBuilderImpl(final String moduleName, final int line, final ConstraintDefinition base) {
  59         this.moduleName = moduleName;
  60         this.line = line;
  61         whenStmt = base.getWhenCondition();
  62         mustDefinitions = new HashSet<>(base.getMustConstraints());
  63         mandatory = base.isMandatory();
  64         min = base.getMinElements();
  65         max = base.getMaxElements();
  66     }
  67
  68     /* (non-Javadoc)
  69      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#build()
  70      */
  71     @Override
  72     public ConstraintDefinition build() {
  73         if (instance != null) {
  74             return instance;
  75         }
  76
  77         if (whenStmt == null) {
  78             if (whenCondition == null) {
  79                 whenStmt = null;
  80             } else {
  81                 whenStmt = new RevisionAwareXPathImpl(whenCondition, false);
  82             }
  83         }
  84
  85         ConstraintDefinitionImpl newInstance = new ConstraintDefinitionImpl();
  86         newInstance.setWhenCondition(whenStmt);
  87         newInstance.setMandatory(mandatory);
  88         newInstance.setMinElements(min);
  89         newInstance.setMaxElements(max);
  90
  91         if (!mustDefinitions.isEmpty()) {
  92             newInstance.setMustConstraints(mustDefinitions);
  93         }
  94         if (EMPTY_CONSTRAINT.equals(newInstance)) {
  95             newInstance = EMPTY_CONSTRAINT;
  96         } else if (EMPTY_MANDATORY_CONSTRAINT.equals(newInstance)) {
  97             newInstance = EMPTY_MANDATORY_CONSTRAINT;
  98         }
  99
 100         instance = newInstance;
 101         return instance;
 102     }
 103
 104     /* (non-Javadoc)
 105      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getModuleName()
 106      */
 107     @Override
 108     public String getModuleName() {
 109         return moduleName;
 110     }
 111
 112     /* (non-Javadoc)
 113      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getLine()
 114      */
 115     @Override
 116     public int getLine() {
 117         return line;
 118     }
 119
 120     /* (non-Javadoc)
 121      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getMinElements()
 122      */
 123     @Override
 124     public Integer getMinElements() {
 125         return min;
 126     }
 127
 128     /* (non-Javadoc)
 129      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#setMinElements(java.lang.Integer)
 130      */
 131     @Override
 132     public void setMinElements(final Integer minElements) {
 133         this.min = minElements;
 134     }
 135
 136     /* (non-Javadoc)
 137      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getMaxElements()
 138      */
 139     @Override
 140     public Integer getMaxElements() {
 141         return max;
 142     }
 143
 144     /* (non-Javadoc)
 145      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#setMaxElements(java.lang.Integer)
 146      */
 147     @Override
 148     public void setMaxElements(final Integer maxElements) {
 149         this.max = maxElements;
 150     }
 151
 152     /* (non-Javadoc)
 153      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getMustDefinitions()
 154      */
 155     @Override
 156     public Set<MustDefinition> getMustDefinitions() {
 157         return mustDefinitions;
 158     }
 159
 160     /* (non-Javadoc)
 161      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#addMustDefinition(org.opendaylight.yangtools.yang.model.api.MustDefinition)
 162      */
 163     @Override
 164     public void addMustDefinition(final MustDefinition must) {
 165         mustDefinitions.add(must);
 166     }
 167
 168     /* (non-Javadoc)
 169      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getWhenCondition()
 170      */
 171     @Override
 172     public String getWhenCondition() {
 173         return whenCondition;
 174     }
 175
 176     /* (non-Javadoc)
 177      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#addWhenCondition(java.lang.String)
 178      */
 179     @Override
 180     public void addWhenCondition(final String whenCondition) {
 181         this.whenCondition = whenCondition;
 182     }
 183
 184     /* (non-Javadoc)
 185      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#isMandatory()
 186      */
 187     @Override
 188     public boolean isMandatory() {
 189         return mandatory;
 190     }
 191
 192     /* (non-Javadoc)
 193      * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#setMandatory(boolean)
 194      */
 195     @Override
 196     public void setMandatory(final boolean mandatory) {
 197         this.mandatory = mandatory;
 198     }
 199
 200     private static final class ConstraintDefinitionImpl implements ConstraintDefinition {
 201         private RevisionAwareXPath whenCondition;
 202         private Set<MustDefinition> mustConstraints = Collections.emptySet();
 203         private Boolean mandatory = false;
 204         private Integer minElements;
 205         private Integer maxElements;
 206
 207         @Override
 208         public RevisionAwareXPath getWhenCondition() {
 209             return whenCondition;
 210         }
 211
 212         private void setWhenCondition(final RevisionAwareXPath whenCondition) {
 213             this.whenCondition = whenCondition;
 214         }
 215
 216         @Override
 217         public Set<MustDefinition> getMustConstraints() {
 218             return mustConstraints;
 219         }
 220
 221         private void setMustConstraints(final Set<MustDefinition> mustConstraints) {
 222             if (mustConstraints != null) {
 223                 this.mustConstraints = ImmutableSet.copyOf(mustConstraints);
 224             }
 225         }
 226
 227         @Override
 228         public boolean isMandatory() {
 229             return mandatory;
 230         }
 231
 232         private void setMandatory(final boolean mandatory) {
 233             this.mandatory = mandatory;
 234         }
 235
 236         @Override
 237         public Integer getMinElements() {
 238             return minElements;
 239         }
 240
 241         private void setMinElements(final Integer minElements) {
 242             this.minElements = minElements;
 243             if (minElements != null && minElements > 0) {
 244                 mandatory = true;
 245             }
 246         }
 247
 248         @Override
 249         public Integer getMaxElements() {
 250             return maxElements;
 251         }
 252
 253         private void setMaxElements(final Integer maxElements) {
 254             this.maxElements = maxElements;
 255         }
 256
 257         @Override
 258         public int hashCode() {
 259             final int prime = 31;
 260             int result = 1;
 261             result = prime * result + Objects.hashCode(whenCondition);
 262             result = prime * result + Objects.hashCode(mustConstraints);
 263             result = prime * result + Objects.hashCode(minElements);
 264             result = prime * result + Objects.hashCode(maxElements);
 265             result = prime * result + mandatory.hashCode();
 266             return result;
 267         }
 268
 269         @Override
 270         public boolean equals(final Object obj) {
 271             if (this == obj) {
 272                 return true;
 273             }
 274             if (obj == null) {
 275                 return false;
 276             }
 277             if (getClass() != obj.getClass()) {
 278                 return false;
 279             }
 280             ConstraintDefinitionImpl other = (ConstraintDefinitionImpl) obj;
 281             if (whenCondition == null) {
 282                 if (other.whenCondition != null) {
 283                     return false;
 284                 }
 285             } else if (!whenCondition.equals(other.whenCondition)) {
 286                 return false;
 287             }
 288             if (mustConstraints == null) {
 289                 if (other.mustConstraints != null) {
 290                     return false;
 291                 }
 292             } else if (!mustConstraints.equals(other.mustConstraints)) {
 293                 return false;
 294             }
 295             if (!mandatory.equals(other.mandatory)) {
 296                 return false;
 297             }
 298             if (minElements == null) {
 299                 if (other.minElements != null) {
 300                     return false;
 301                 }
 302             } else if (!minElements.equals(other.minElements)) {
 303                 return false;
 304             }
 305             if (maxElements == null) {
 306                 if (other.maxElements != null) {
 307                     return false;
 308                 }
 309             } else if (!maxElements.equals(other.maxElements)) {
 310                 return false;
 311             }
 312             return true;
 313         }
 314
 315         @Override
 316         public String toString() {
 317             StringBuilder sb = new StringBuilder(ConstraintDefinitionImpl.class.getSimpleName());
 318             sb.append("[");
 319             sb.append("whenCondition=").append(whenCondition);
 320             sb.append(", mustConstraints=").append(mustConstraints);
 321             sb.append(", mandatory=").append(mandatory);
 322             sb.append(", minElements=").append(minElements);
 323             sb.append(", maxElements=").append(maxElements);
 324             sb.append("]");
 325             return sb.toString();
 326         }
 327     }
 328
 329     /*
 330      * @deprecated Use #build() instead.
 331      */
 332     @Override
 333     @Deprecated
 334     public ConstraintDefinition toInstance() {
 335         return build();
 336     }
 337
 338 }