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