yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/TypeDefinitionBuilderImpl.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.base.Optional;
  11 import com.google.common.base.Preconditions;
  12 import java.util.Collections;
  13 import java.util.List;
  14 import java.util.Objects;
  15 import org.opendaylight.yangtools.yang.common.QName;
  16 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  17 import org.opendaylight.yangtools.yang.model.api.Status;
  18 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  19 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
  20 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
  21 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  22 import org.opendaylight.yangtools.yang.model.util.ExtendedType;
  23 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
  26 import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
  27 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  28
  29 public final class TypeDefinitionBuilderImpl extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
  30     private SchemaPath schemaPath;
  31     private List<RangeConstraint> ranges = Collections.emptyList();
  32     private List<LengthConstraint> lengths = Collections.emptyList();
  33     private List<PatternConstraint> patterns = Collections.emptyList();
  34     private Integer fractionDigits = null;
  35
  36     private String description;
  37     private String reference;
  38     private Status status = Status.CURRENT;
  39     private String units;
  40     private Object defaultValue;
  41     private boolean addedByUses;
  42
  43     public TypeDefinitionBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  44         super(moduleName, line, qname);
  45         this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
  46     }
  47
  48     public TypeDefinitionBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path, final ExtendedType base) {
  49         super(moduleName, line, base.getQName());
  50         this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
  51
  52         this.type = base.getBaseType();
  53         this.description = base.getDescription();
  54         this.reference = base.getReference();
  55         this.status = base.getStatus();
  56         this.units = base.getUnits();
  57         this.defaultValue = base.getDefaultValue();
  58
  59         this.addedByUses = base.isAddedByUses();
  60         this.ranges = base.getRangeConstraints();
  61         this.lengths = base.getLengthConstraints();
  62         this.patterns = base.getPatternConstraints();
  63         this.fractionDigits = base.getFractionDigits();
  64         this.unknownNodes.addAll(base.getUnknownSchemaNodes());
  65     }
  66
  67     @Override
  68     public TypeDefinition<? extends TypeDefinition<?>> build() {
  69         TypeDefinition<?> result;
  70         ExtendedType.Builder typeBuilder;
  71         if (type == null) {
  72             if (typedef == null) {
  73                 throw new YangParseException("Unresolved type: '" + qname.getLocalName() + "'.");
  74             } else {
  75                 type = typedef.build();
  76             }
  77         }
  78
  79         typeBuilder = ExtendedType.builder(qname, type, Optional.fromNullable(description),
  80                 Optional.fromNullable(reference), schemaPath);
  81         typeBuilder.status(status);
  82         typeBuilder.units(units);
  83         typeBuilder.defaultValue(defaultValue);
  84         typeBuilder.addedByUses(addedByUses);
  85         typeBuilder.ranges(ranges);
  86         typeBuilder.lengths(lengths);
  87         typeBuilder.patterns(patterns);
  88         typeBuilder.fractionDigits(fractionDigits);
  89
  90         // UNKNOWN NODES
  91         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
  92             unknownNodes.add(b.build());
  93         }
  94         Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
  95         typeBuilder.unknownSchemaNodes(unknownNodes);
  96         result = typeBuilder.build();
  97         return result;
  98     }
  99
 100     @Override
 101     public void setQName(final QName qname) {
 102         this.qname = qname;
 103     }
 104
 105     @Override
 106     public SchemaPath getPath() {
 107         return schemaPath;
 108     }
 109
 110     @Override
 111     public void setPath(final SchemaPath path) {
 112         this.schemaPath = path;
 113     }
 114
 115     @Override
 116     public String getDescription() {
 117         return description;
 118     }
 119
 120     @Override
 121     public void setDescription(final String description) {
 122         this.description = description;
 123     }
 124
 125     @Override
 126     public String getReference() {
 127         return reference;
 128     }
 129
 130     @Override
 131     public void setReference(final String reference) {
 132         this.reference = reference;
 133     }
 134
 135     @Override
 136     public Status getStatus() {
 137         return status;
 138     }
 139
 140     @Override
 141     public void setStatus(final Status status) {
 142         if (status != null) {
 143             this.status = status;
 144         }
 145     }
 146
 147     @Override
 148     public boolean isAddedByUses() {
 149         return addedByUses;
 150     }
 151
 152     @Override
 153     public void setAddedByUses(final boolean addedByUses) {
 154         this.addedByUses = addedByUses;
 155     }
 156
 157     @Override
 158     public String getUnits() {
 159         return units;
 160     }
 161
 162     @Override
 163     public void setUnits(final String units) {
 164         this.units = units;
 165     }
 166
 167     @Override
 168     public Object getDefaultValue() {
 169         return defaultValue;
 170     }
 171
 172     @Override
 173     public void setDefaultValue(final Object defaultValue) {
 174         this.defaultValue = defaultValue;
 175     }
 176
 177     @Override
 178     public List<RangeConstraint> getRanges() {
 179         return ranges;
 180     }
 181
 182     @Override
 183     public void setRanges(final List<RangeConstraint> ranges) {
 184         if (ranges != null) {
 185             this.ranges = ranges;
 186         }
 187     }
 188
 189     @Override
 190     public List<LengthConstraint> getLengths() {
 191         return lengths;
 192     }
 193
 194     @Override
 195     public void setLengths(final List<LengthConstraint> lengths) {
 196         if (lengths != null) {
 197             this.lengths = lengths;
 198         }
 199     }
 200
 201     @Override
 202     public List<PatternConstraint> getPatterns() {
 203         return patterns;
 204     }
 205
 206     @Override
 207     public void setPatterns(final List<PatternConstraint> patterns) {
 208         if (patterns != null) {
 209             this.patterns = patterns;
 210         }
 211     }
 212
 213     @Override
 214     public Integer getFractionDigits() {
 215         return fractionDigits;
 216     }
 217
 218     @Override
 219     public void setFractionDigits(final Integer fractionDigits) {
 220         this.fractionDigits = fractionDigits;
 221     }
 222
 223     @Override
 224     public String toString() {
 225         return "typedef " + qname.getLocalName();
 226     }
 227
 228     @Override
 229     public int hashCode() {
 230         final int prime = 31;
 231         int result = super.hashCode();
 232         result = prime * result + Objects.hashCode(schemaPath);
 233
 234         return result;
 235     }
 236
 237     @Override
 238     public boolean equals(final Object obj) {
 239         if (this == obj) {
 240             return true;
 241         }
 242         if (obj == null) {
 243             return false;
 244         }
 245         if (getClass() != obj.getClass()) {
 246             return false;
 247         }
 248         if (!super.equals(obj)) {
 249             return false;
 250         }
 251         TypeDefinitionBuilderImpl other = (TypeDefinitionBuilderImpl) obj;
 252
 253         if (schemaPath == null) {
 254             if (other.schemaPath != null) {
 255                 return false;
 256             }
 257         } else if (!schemaPath.equals(other.schemaPath)) {
 258             return false;
 259         }
 260
 261         return true;
 262     }
 263
 264 }