opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/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.controller.yang.parser.builder.impl;
   9
  10 import java.util.ArrayList;
  11 import java.util.Collections;
  12 import java.util.List;
  13
  14 import org.opendaylight.controller.yang.common.QName;
  15 import org.opendaylight.controller.yang.model.api.SchemaPath;
  16 import org.opendaylight.controller.yang.model.api.Status;
  17 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  18 import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
  19 import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
  20 import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
  21 import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
  22 import org.opendaylight.controller.yang.model.util.ExtendedType;
  23 import org.opendaylight.controller.yang.model.util.UnknownType;
  24 import org.opendaylight.controller.yang.parser.builder.api.AbstractTypeAwareBuilder;
  25 import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
  26 import org.opendaylight.controller.yang.parser.util.YangParseException;
  27
  28 public final class TypeDefinitionBuilderImpl extends AbstractTypeAwareBuilder
  29         implements TypeDefinitionBuilder {
  30     private final int line;
  31     private final QName qname;
  32     private SchemaPath schemaPath;
  33
  34     private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
  35     private List<UnknownSchemaNode> unknownNodes;
  36     private List<RangeConstraint> ranges = Collections.emptyList();
  37     private List<LengthConstraint> lengths = Collections.emptyList();
  38     private List<PatternConstraint> patterns = Collections.emptyList();
  39     private Integer fractionDigits = null;
  40
  41     private String description;
  42     private String reference;
  43     private Status status = Status.CURRENT;
  44     private String units;
  45     private Object defaultValue;
  46
  47     public TypeDefinitionBuilderImpl(final QName qname, final int line) {
  48         this.qname = qname;
  49         this.line = line;
  50     }
  51
  52     @Override
  53     public TypeDefinition<? extends TypeDefinition<?>> build() {
  54         TypeDefinition<?> result = null;
  55         ExtendedType.Builder typeBuilder = null;
  56         if ((type == null || type instanceof UnknownType) && typedef == null) {
  57             throw new YangParseException("Unresolved type: '"
  58                     + qname.getLocalName() + "'.");
  59         }
  60         if (type == null || type instanceof UnknownType) {
  61             type = typedef.build();
  62         }
  63
  64         typeBuilder = new ExtendedType.Builder(qname, type, description,
  65                 reference, schemaPath);
  66
  67         typeBuilder.status(status);
  68         typeBuilder.units(units);
  69         typeBuilder.defaultValue(defaultValue);
  70
  71         typeBuilder.ranges(ranges);
  72         typeBuilder.lengths(lengths);
  73         typeBuilder.patterns(patterns);
  74         typeBuilder.fractionDigits(fractionDigits);
  75
  76         // UNKNOWN NODES
  77         if (unknownNodes == null) {
  78             unknownNodes = new ArrayList<UnknownSchemaNode>();
  79             for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
  80                 unknownNodes.add(b.build());
  81             }
  82         }
  83         typeBuilder.unknownSchemaNodes(unknownNodes);
  84         result = typeBuilder.build();
  85         return result;
  86     }
  87
  88     @Override
  89     public int getLine() {
  90         return line;
  91     }
  92
  93     @Override
  94     public QName getQName() {
  95         return qname;
  96     }
  97
  98     @Override
  99     public SchemaPath getPath() {
 100         return schemaPath;
 101     }
 102
 103     @Override
 104     public void setPath(final SchemaPath schemaPath) {
 105         this.schemaPath = schemaPath;
 106     }
 107
 108     @Override
 109     public String getDescription() {
 110         return description;
 111     }
 112
 113     @Override
 114     public void setDescription(final String description) {
 115         this.description = description;
 116     }
 117
 118     @Override
 119     public String getReference() {
 120         return reference;
 121     }
 122
 123     @Override
 124     public void setReference(final String reference) {
 125         this.reference = reference;
 126     }
 127
 128     @Override
 129     public Status getStatus() {
 130         return status;
 131     }
 132
 133     @Override
 134     public void setStatus(final Status status) {
 135         if (status != null) {
 136             this.status = status;
 137         }
 138     }
 139
 140     @Override
 141     public String getUnits() {
 142         return units;
 143     }
 144
 145     @Override
 146     public void setUnits(final String units) {
 147         this.units = units;
 148     }
 149
 150     @Override
 151     public Object getDefaultValue() {
 152         return defaultValue;
 153     }
 154
 155     @Override
 156     public void setDefaultValue(final Object defaultValue) {
 157         this.defaultValue = defaultValue;
 158     }
 159
 160     @Override
 161     public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
 162         return addedUnknownNodes;
 163     }
 164
 165     @Override
 166     public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
 167         addedUnknownNodes.add(unknownNode);
 168     }
 169
 170     public void setUnknownNodes(List<UnknownSchemaNode> unknownNodes) {
 171         this.unknownNodes = unknownNodes;
 172     }
 173
 174     @Override
 175     public List<RangeConstraint> getRanges() {
 176         return ranges;
 177     }
 178
 179     @Override
 180     public void setRanges(final List<RangeConstraint> ranges) {
 181         if (ranges != null) {
 182             this.ranges = ranges;
 183         }
 184     }
 185
 186     @Override
 187     public List<LengthConstraint> getLengths() {
 188         return lengths;
 189     }
 190
 191     @Override
 192     public void setLengths(final List<LengthConstraint> lengths) {
 193         if (lengths != null) {
 194             this.lengths = lengths;
 195         }
 196     }
 197
 198     @Override
 199     public List<PatternConstraint> getPatterns() {
 200         return patterns;
 201     }
 202
 203     @Override
 204     public void setPatterns(final List<PatternConstraint> patterns) {
 205         if (patterns != null) {
 206             this.patterns = patterns;
 207         }
 208     }
 209
 210     @Override
 211     public Integer getFractionDigits() {
 212         return fractionDigits;
 213     }
 214
 215     @Override
 216     public void setFractionDigits(final Integer fractionDigits) {
 217         this.fractionDigits = fractionDigits;
 218     }
 219
 220     @Override
 221     public String toString() {
 222         final StringBuilder result = new StringBuilder("TypedefBuilder["
 223                 + qname.getLocalName());
 224         result.append(", type=");
 225         if (type == null) {
 226             result.append(typedef);
 227         } else {
 228             result.append(type);
 229         }
 230         result.append("]");
 231         return result.toString();
 232     }
 233
 234 }