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.net.URI;
  14 import java.util.ArrayList;
  15 import java.util.Date;
  16 import java.util.List;
  17 import java.util.Set;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  20 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
  21 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  22 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  23 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
  26 import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
  27 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  28 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  29 import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainer;
  30 import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
  31
  32 public final class ListSchemaNodeBuilder extends AbstractDocumentedDataNodeContainerBuilder implements DataSchemaNodeBuilder,
  33         AugmentationTargetBuilder {
  34     private ListSchemaNodeImpl instance;
  35     private boolean userOrdered;
  36     private List<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 boolean configuration;
  44     private final ConstraintsBuilder constraints;
  45     // AugmentationTarget args
  46     private final List<AugmentationSchema> augmentations = new ArrayList<>();
  47     private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
  48
  49     public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  50         super(moduleName, line, qname);
  51         this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
  52         constraints = new ConstraintsBuilderImpl(moduleName, line);
  53     }
  54
  55     public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
  56             final ListSchemaNode base) {
  57         super(moduleName, line, qname,path,base);
  58         this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
  59         constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
  60
  61         keyDefinition = ImmutableList.copyOf(base.getKeyDefinition());
  62         userOrdered = base.isUserOrdered();
  63
  64         augmenting = base.isAugmenting();
  65         addedByUses = base.isAddedByUses();
  66         configuration = base.isConfiguration();
  67
  68         URI ns = qname.getNamespace();
  69         Date rev = qname.getRevision();
  70         String pref = qname.getPrefix();
  71         addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
  72                 rev, pref));
  73
  74         augmentations.addAll(base.getAvailableAugmentations());
  75     }
  76
  77     @Override
  78     public ListSchemaNode build() {
  79         if (instance != null) {
  80             return instance;
  81         }
  82         buildChildren();
  83         instance = new ListSchemaNodeImpl(qname, schemaPath,this);
  84
  85         instance.augmenting = augmenting;
  86         instance.addedByUses = addedByUses;
  87         instance.configuration = configuration;
  88         instance.constraints = constraints.toInstance();
  89         instance.userOrdered = userOrdered;
  90
  91         // KEY
  92         if (keys == null) {
  93             instance.keyDefinition = ImmutableList.of();
  94         } else {
  95             keyDefinition = new ArrayList<>();
  96             for (String key : keys) {
  97                 keyDefinition.add(instance.getDataChildByName(key).getQName());
  98             }
  99             instance.keyDefinition = ImmutableList.copyOf(keyDefinition);
 100         }
 101
 102         // AUGMENTATIONS
 103         for (AugmentationSchemaBuilder builder : augmentationBuilders) {
 104             augmentations.add(builder.build());
 105         }
 106         instance.augmentations = ImmutableSet.copyOf(augmentations);
 107
 108         // UNKNOWN NODES
 109         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
 110             unknownNodes.add(b.build());
 111         }
 112         instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
 113
 114         return instance;
 115     }
 116
 117     @Override
 118     protected String getStatementName() {
 119         return "list";
 120     }
 121
 122     @Override
 123     public SchemaPath getPath() {
 124         return schemaPath;
 125     }
 126
 127     @Override
 128     public void setPath(final SchemaPath path) {
 129         this.schemaPath = path;
 130     }
 131
 132     @Override
 133     public void addAugmentation(final AugmentationSchemaBuilder augment) {
 134         augmentationBuilders.add(augment);
 135     }
 136
 137     public List<AugmentationSchemaBuilder> getAugmentationBuilders() {
 138         return augmentationBuilders;
 139     }
 140
 141     public List<String> getKeys() {
 142         return keys;
 143     }
 144
 145     public void setKeys(final List<String> keys) {
 146         this.keys = keys;
 147     }
 148
 149     @Override
 150     public boolean isAugmenting() {
 151         return augmenting;
 152     }
 153
 154     @Override
 155     public void setAugmenting(final boolean augmenting) {
 156         this.augmenting = augmenting;
 157     }
 158
 159     @Override
 160     public boolean isAddedByUses() {
 161         return addedByUses;
 162     }
 163
 164     @Override
 165     public void setAddedByUses(final boolean addedByUses) {
 166         this.addedByUses = addedByUses;
 167     }
 168
 169     @Override
 170     public boolean isConfiguration() {
 171         return configuration;
 172     }
 173
 174     @Override
 175     public void setConfiguration(final boolean configuration) {
 176         this.configuration = configuration;
 177     }
 178
 179     @Override
 180     public ConstraintsBuilder getConstraints() {
 181         return constraints;
 182     }
 183
 184     public boolean isUserOrdered() {
 185         return userOrdered;
 186     }
 187
 188     public void setUserOrdered(final boolean userOrdered) {
 189         this.userOrdered = userOrdered;
 190     }
 191
 192     @Override
 193     public int hashCode() {
 194         final int prime = 31;
 195         int result = 1;
 196         result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
 197         return result;
 198     }
 199
 200     @Override
 201     public boolean equals(final Object obj) {
 202         if (this == obj) {
 203             return true;
 204         }
 205         if (obj == null) {
 206             return false;
 207         }
 208         if (getClass() != obj.getClass()) {
 209             return false;
 210         }
 211         ListSchemaNodeBuilder other = (ListSchemaNodeBuilder) obj;
 212         if (schemaPath == null) {
 213             if (other.schemaPath != null) {
 214                 return false;
 215             }
 216         } else if (!schemaPath.equals(other.schemaPath)) {
 217             return false;
 218         }
 219         if (getParent() == null) {
 220             if (other.getParent() != null) {
 221                 return false;
 222             }
 223         } else if (!getParent().equals(other.getParent())) {
 224             return false;
 225         }
 226         return true;
 227     }
 228
 229     @Override
 230     public String toString() {
 231         return "list " + qname.getLocalName();
 232     }
 233
 234     private static final class ListSchemaNodeImpl extends AbstractDocumentedDataNodeContainer implements ListSchemaNode {
 235         private final QName qname;
 236         private final SchemaPath path;
 237         private ImmutableList<QName> keyDefinition;
 238         private boolean augmenting;
 239         private boolean addedByUses;
 240         private boolean configuration;
 241         private ConstraintDefinition constraints;
 242         private ImmutableSet<AugmentationSchema> augmentations;
 243         private ImmutableList<UnknownSchemaNode> unknownNodes;
 244         private boolean userOrdered;
 245
 246         private ListSchemaNodeImpl(final QName qname, final SchemaPath path, final ListSchemaNodeBuilder builder) {
 247             super(builder);
 248             this.qname = qname;
 249             this.path = path;
 250         }
 251
 252         @Override
 253         public QName getQName() {
 254             return qname;
 255         }
 256
 257         @Override
 258         public SchemaPath getPath() {
 259             return path;
 260         }
 261
 262         @Override
 263         public List<QName> getKeyDefinition() {
 264             return keyDefinition;
 265         }
 266
 267         @Override
 268         public boolean isAugmenting() {
 269             return augmenting;
 270         }
 271
 272         @Override
 273         public boolean isAddedByUses() {
 274             return addedByUses;
 275         }
 276
 277         @Override
 278         public boolean isConfiguration() {
 279             return configuration;
 280         }
 281
 282         @Override
 283         public ConstraintDefinition getConstraints() {
 284             return constraints;
 285         }
 286
 287         @Override
 288         public Set<AugmentationSchema> getAvailableAugmentations() {
 289             return augmentations;
 290         }
 291
 292         @Override
 293         public boolean isUserOrdered() {
 294             return userOrdered;
 295         }
 296
 297         @Override
 298         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 299             return unknownNodes;
 300         }
 301
 302         @Override
 303         public int hashCode() {
 304             final int prime = 31;
 305             int result = 1;
 306             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 307             result = prime * result + ((path == null) ? 0 : path.hashCode());
 308             return result;
 309         }
 310
 311         @Override
 312         public boolean equals(final Object obj) {
 313             if (this == obj) {
 314                 return true;
 315             }
 316             if (obj == null) {
 317                 return false;
 318             }
 319             if (getClass() != obj.getClass()) {
 320                 return false;
 321             }
 322             final ListSchemaNodeImpl other = (ListSchemaNodeImpl) obj;
 323             if (qname == null) {
 324                 if (other.qname != null) {
 325                     return false;
 326                 }
 327             } else if (!qname.equals(other.qname)) {
 328                 return false;
 329             }
 330             if (path == null) {
 331                 if (other.path != null) {
 332                     return false;
 333                 }
 334             } else if (!path.equals(other.path)) {
 335                 return false;
 336             }
 337             return true;
 338         }
 339
 340         @Override
 341         public String toString() {
 342             return "list " + qname.getLocalName();
 343         }
 344     }
 345
 346 }