yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ListSchemaNodeBuilder.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.Preconditions;
  11 import com.google.common.collect.ImmutableList;
  12 import com.google.common.collect.ImmutableSet;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import java.util.Set;
  16 import org.opendaylight.yangtools.yang.common.QName;
  17 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  18 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  19 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  20 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  21 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  22 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  23 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  26 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  27 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  28 import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
  29 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  30
  31 public final class ListSchemaNodeBuilder extends AbstractDocumentedDataNodeContainerBuilder implements
  32         DataSchemaNodeBuilder, AugmentationTargetBuilder {
  33     private ListSchemaNodeImpl instance;
  34     private boolean userOrdered;
  35     private Set<String> keys;
  36     private List<QName> keyDefinition;
  37     // SchemaNode args
  38     private SchemaPath schemaPath;
  39     // DataSchemaNode args
  40     private boolean augmenting;
  41     private boolean addedByUses;
  42     private ListSchemaNodeBuilder originalBuilder;
  43     private ListSchemaNode originalNode;
  44     private boolean configuration;
  45     private final ConstraintsBuilder constraints;
  46     // AugmentationTarget args
  47     private final List<AugmentationSchema> augmentations = new ArrayList<>();
  48     private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
  49
  50     public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  51         super(moduleName, line, qname);
  52         this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
  53         constraints = new ConstraintsBuilderImpl(moduleName, line);
  54     }
  55
  56     public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
  57             final ListSchemaNode base) {
  58         super(moduleName, line, qname, path, base);
  59         this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
  60         constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
  61
  62         keyDefinition = ImmutableList.copyOf(base.getKeyDefinition());
  63         userOrdered = base.isUserOrdered();
  64
  65         augmenting = base.isAugmenting();
  66         addedByUses = base.isAddedByUses();
  67         originalNode = base;
  68         configuration = base.isConfiguration();
  69
  70         addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path,
  71                 qname));
  72         augmentations.addAll(base.getAvailableAugmentations());
  73     }
  74
  75     @Override
  76     public ListSchemaNode build() {
  77         if (instance != null) {
  78             return instance;
  79         }
  80         buildChildren();
  81         instance = new ListSchemaNodeImpl(qname, schemaPath, this);
  82
  83         instance.augmenting = augmenting;
  84         instance.addedByUses = addedByUses;
  85         instance.configuration = configuration;
  86         instance.constraints = constraints.toInstance();
  87         instance.userOrdered = userOrdered;
  88
  89         // KEY
  90         if (keys != null) {
  91             keyDefinition = new ArrayList<>();
  92             for (String key : keys) {
  93                 DataSchemaNode keyPart = instance.getDataChildByName(key);
  94                 if (keyPart == null) {
  95                     throw new YangParseException(getModuleName(), getLine(), "Failed to resolve list key for name "
  96                             + key);
  97                 }
  98
  99                 if (!(keyPart instanceof LeafSchemaNode)) {
 100                     throw new YangParseException(getModuleName(), getLine(), "List key : \"" + key
 101                             + "\" does not reference any Leaf of the List");
 102                 }
 103
 104                 final QName qname = keyPart.getQName();
 105                 if (!keyDefinition.contains(qname)) {
 106                     keyDefinition.add(qname);
 107                 }
 108             }
 109             instance.keyDefinition = ImmutableList.copyOf(keyDefinition);
 110         } else {
 111             instance.keyDefinition = ImmutableList.of();
 112         }
 113
 114         // ORIGINAL NODE
 115         if (originalNode == null && originalBuilder != null) {
 116             originalNode = originalBuilder.build();
 117         }
 118         instance.original = originalNode;
 119
 120         // AUGMENTATIONS
 121         for (AugmentationSchemaBuilder builder : augmentationBuilders) {
 122             augmentations.add(builder.build());
 123         }
 124         instance.augmentations = ImmutableSet.copyOf(augmentations);
 125
 126         // UNKNOWN NODES
 127         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
 128             unknownNodes.add(b.build());
 129         }
 130         instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
 131
 132         return instance;
 133     }
 134
 135     @Override
 136     protected String getStatementName() {
 137         return "list";
 138     }
 139
 140     @Override
 141     public SchemaPath getPath() {
 142         return schemaPath;
 143     }
 144
 145     @Override
 146     public void setPath(final SchemaPath path) {
 147         this.schemaPath = path;
 148     }
 149
 150     @Override
 151     public void addAugmentation(final AugmentationSchemaBuilder augment) {
 152         augmentationBuilders.add(augment);
 153     }
 154
 155     public List<AugmentationSchemaBuilder> getAugmentationBuilders() {
 156         return augmentationBuilders;
 157     }
 158
 159     public Set<String> getKeys() {
 160         return keys;
 161     }
 162
 163     public void setKeys(final Set<String> keys) {
 164         this.keys = keys;
 165     }
 166
 167     @Override
 168     public boolean isAugmenting() {
 169         return augmenting;
 170     }
 171
 172     @Override
 173     public void setAugmenting(final boolean augmenting) {
 174         this.augmenting = augmenting;
 175     }
 176
 177     @Override
 178     public boolean isAddedByUses() {
 179         return addedByUses;
 180     }
 181
 182     @Override
 183     public void setAddedByUses(final boolean addedByUses) {
 184         this.addedByUses = addedByUses;
 185     }
 186
 187     @Override
 188     public ListSchemaNodeBuilder getOriginal() {
 189         return originalBuilder;
 190     }
 191
 192     @Override
 193     public void setOriginal(final SchemaNodeBuilder builder) {
 194         Preconditions.checkArgument(builder instanceof ListSchemaNodeBuilder, "Original of list cannot be " + builder);
 195         this.originalBuilder = (ListSchemaNodeBuilder) builder;
 196     }
 197
 198     @Override
 199     public boolean isConfiguration() {
 200         return configuration;
 201     }
 202
 203     @Override
 204     public void setConfiguration(final boolean configuration) {
 205         this.configuration = configuration;
 206     }
 207
 208     @Override
 209     public ConstraintsBuilder getConstraints() {
 210         return constraints;
 211     }
 212
 213     public boolean isUserOrdered() {
 214         return userOrdered;
 215     }
 216
 217     public void setUserOrdered(final boolean userOrdered) {
 218         this.userOrdered = userOrdered;
 219     }
 220
 221     @Override
 222     public int hashCode() {
 223         final int prime = 31;
 224         int result = 1;
 225         result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
 226         return result;
 227     }
 228
 229     @Override
 230     public boolean equals(final Object obj) {
 231         if (this == obj) {
 232             return true;
 233         }
 234         if (obj == null) {
 235             return false;
 236         }
 237         if (getClass() != obj.getClass()) {
 238             return false;
 239         }
 240         ListSchemaNodeBuilder other = (ListSchemaNodeBuilder) obj;
 241         if (schemaPath == null) {
 242             if (other.schemaPath != null) {
 243                 return false;
 244             }
 245         } else if (!schemaPath.equals(other.schemaPath)) {
 246             return false;
 247         }
 248         if (getParent() == null) {
 249             if (other.getParent() != null) {
 250                 return false;
 251             }
 252         } else if (!getParent().equals(other.getParent())) {
 253             return false;
 254         }
 255         return true;
 256     }
 257
 258     @Override
 259     public String toString() {
 260         return "list " + qname.getLocalName();
 261     }
 262
 263 }