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