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