yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ConstraintsBuilder.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 java.util.Collections;
  11 import java.util.HashSet;
  12 import java.util.List;
  13 import java.util.Set;
  14
  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.AbstractBuilder;
  20 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  21
  22 public final class ConstraintsBuilder extends AbstractBuilder {
  23     private final ConstraintDefinitionImpl instance;
  24     private final Set<MustDefinition> mustDefinitions;
  25     private String whenCondition;
  26     private boolean mandatory;
  27     private Integer min;
  28     private Integer max;
  29
  30     ConstraintsBuilder(final String moduleName, final int line) {
  31         super(moduleName, line);
  32         instance = new ConstraintDefinitionImpl();
  33         mustDefinitions = new HashSet<MustDefinition>();
  34     }
  35
  36     ConstraintsBuilder(final ConstraintsBuilder b) {
  37         super(b.getModuleName(), b.getLine());
  38         instance = new ConstraintDefinitionImpl();
  39         mustDefinitions = new HashSet<MustDefinition>(b.getMustDefinitions());
  40         whenCondition = b.getWhenCondition();
  41         mandatory = b.isMandatory();
  42         min = b.getMinElements();
  43         max = b.getMaxElements();
  44     }
  45
  46     @Override
  47     public ConstraintDefinition build() {
  48         RevisionAwareXPath whenStmt;
  49         if (whenCondition == null) {
  50             whenStmt = null;
  51         } else {
  52             whenStmt = new RevisionAwareXPathImpl(whenCondition, false);
  53         }
  54         instance.setWhenCondition(whenStmt);
  55         instance.setMustConstraints(mustDefinitions);
  56         instance.setMandatory(mandatory);
  57         instance.setMinElements(min);
  58         instance.setMaxElements(max);
  59         return instance;
  60     }
  61
  62     @Override
  63     public void addUnknownNodeBuilder(UnknownSchemaNodeBuilder unknownNode) {
  64         throw new YangParseException(moduleName, line, "Can not add unknown node to constraints.");
  65     }
  66
  67     @Override
  68     public List<UnknownSchemaNodeBuilder> getUnknownNodeBuilders() {
  69         return Collections.emptyList();
  70     }
  71
  72     public Integer getMinElements() {
  73         return min;
  74     }
  75
  76     public void setMinElements(Integer minElements) {
  77         this.min = minElements;
  78     }
  79
  80     public Integer getMaxElements() {
  81         return max;
  82     }
  83
  84     public void setMaxElements(Integer maxElements) {
  85         this.max = maxElements;
  86     }
  87
  88     public Set<MustDefinition> getMustDefinitions() {
  89         return mustDefinitions;
  90     }
  91
  92     public void addMustDefinition(MustDefinition must) {
  93         mustDefinitions.add(must);
  94     }
  95
  96     public String getWhenCondition() {
  97         return whenCondition;
  98     }
  99
 100     public void addWhenCondition(String whenCondition) {
 101         this.whenCondition = whenCondition;
 102     }
 103
 104     public boolean isMandatory() {
 105         return mandatory;
 106     }
 107
 108     public void setMandatory(boolean mandatory) {
 109         this.mandatory = mandatory;
 110     }
 111
 112     private final class ConstraintDefinitionImpl implements ConstraintDefinition {
 113         private RevisionAwareXPath whenCondition;
 114         private Set<MustDefinition> mustConstraints;
 115         private boolean mandatory;
 116         private Integer minElements;
 117         private Integer maxElements;
 118
 119         @Override
 120         public RevisionAwareXPath getWhenCondition() {
 121             return whenCondition;
 122         }
 123
 124         private void setWhenCondition(RevisionAwareXPath whenCondition) {
 125             this.whenCondition = whenCondition;
 126         }
 127
 128         @Override
 129         public Set<MustDefinition> getMustConstraints() {
 130             if (mustConstraints == null) {
 131                 return Collections.emptySet();
 132             } else {
 133                 return mustConstraints;
 134             }
 135         }
 136
 137         private void setMustConstraints(Set<MustDefinition> mustConstraints) {
 138             if (mustConstraints != null) {
 139                 this.mustConstraints = mustConstraints;
 140             }
 141         }
 142
 143         @Override
 144         public boolean isMandatory() {
 145             return mandatory;
 146         }
 147
 148         private void setMandatory(boolean mandatory) {
 149             this.mandatory = mandatory;
 150         }
 151
 152         @Override
 153         public Integer getMinElements() {
 154             return minElements;
 155         }
 156
 157         private void setMinElements(Integer minElements) {
 158             this.minElements = minElements;
 159         }
 160
 161         @Override
 162         public Integer getMaxElements() {
 163             return maxElements;
 164         }
 165
 166         private void setMaxElements(Integer maxElements) {
 167             this.maxElements = maxElements;
 168         }
 169
 170         @Override
 171         public int hashCode() {
 172             final int prime = 31;
 173             int result = 1;
 174             result = prime * result + ((whenCondition == null) ? 0 : whenCondition.hashCode());
 175             result = prime * result + ((mustConstraints == null) ? 0 : mustConstraints.hashCode());
 176             result = prime * result + ((minElements == null) ? 0 : minElements.hashCode());
 177             result = prime * result + ((maxElements == null) ? 0 : maxElements.hashCode());
 178             result = prime * result + (mandatory ? 1231 : 1237);
 179             return result;
 180         }
 181
 182         @Override
 183         public boolean equals(Object obj) {
 184             if (this == obj) {
 185                 return true;
 186             }
 187             if (obj == null) {
 188                 return false;
 189             }
 190             if (getClass() != obj.getClass()) {
 191                 return false;
 192             }
 193             ConstraintDefinitionImpl other = (ConstraintDefinitionImpl) obj;
 194             if (whenCondition == null) {
 195                 if (other.whenCondition != null) {
 196                     return false;
 197                 }
 198             } else if (!whenCondition.equals(other.whenCondition)) {
 199                 return false;
 200             }
 201             if (mustConstraints == null) {
 202                 if (other.mustConstraints != null) {
 203                     return false;
 204                 }
 205             } else if (!mustConstraints.equals(other.mustConstraints)) {
 206                 return false;
 207             }
 208             if (mandatory != other.mandatory) {
 209                 return false;
 210             }
 211             if (minElements == null) {
 212                 if (other.minElements != null) {
 213                     return false;
 214                 }
 215             } else if (!minElements.equals(other.minElements)) {
 216                 return false;
 217             }
 218             if (maxElements == null) {
 219                 if (other.maxElements != null) {
 220                     return false;
 221                 }
 222             } else if (!maxElements.equals(other.maxElements)) {
 223                 return false;
 224             }
 225             return true;
 226         }
 227
 228         @Override
 229         public String toString() {
 230             StringBuilder sb = new StringBuilder(ConstraintDefinitionImpl.class.getSimpleName());
 231             sb.append("[");
 232             sb.append("whenCondition=" + whenCondition);
 233             sb.append(", mustConstraints=" + mustConstraints);
 234             sb.append(", mandatory=" + mandatory);
 235             sb.append(", minElements=" + minElements);
 236             sb.append(", maxElements=" + maxElements);
 237             sb.append("]");
 238             return sb.toString();
 239         }
 240     }
 241
 242 }