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 java.net.URI;
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.Date;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Set;
  17 import java.util.TreeSet;
  18
  19 import org.opendaylight.yangtools.yang.common.QName;
  20 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  21 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
  22 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  23 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  24 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  25 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  26 import org.opendaylight.yangtools.yang.model.api.Status;
  27 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  29 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  30 import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
  31 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  32 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
  33 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  34 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
  35 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
  36 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
  37 import org.opendaylight.yangtools.yang.parser.util.Comparators;
  38 import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
  39 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  40
  41 public final class ListSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
  42         AugmentationTargetBuilder {
  43     private boolean isBuilt;
  44     private final ListSchemaNodeImpl instance;
  45     private List<String> keys;
  46     // SchemaNode args
  47     private final SchemaPath schemaPath;
  48     // DataSchemaNode args
  49     private final ConstraintsBuilder constraints;
  50     // AugmentationTarget args
  51     private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
  52
  53
  54     public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  55         super(moduleName, line, qname);
  56         this.schemaPath = path;
  57         instance = new ListSchemaNodeImpl(qname, path);
  58         constraints = new ConstraintsBuilder(moduleName, line);
  59     }
  60
  61     public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final ListSchemaNode base) {
  62         super(moduleName, line, qname);
  63         schemaPath = path;
  64         instance = new ListSchemaNodeImpl(qname, path);
  65         constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
  66
  67         instance.keyDefinition = base.getKeyDefinition();
  68         instance.userOrdered = base.isUserOrdered();
  69
  70         instance.description = base.getDescription();
  71         instance.reference = base.getReference();
  72         instance.status = base.getStatus();
  73         instance.augmenting = base.isAugmenting();
  74         instance.addedByUses = base.isAddedByUses();
  75         instance.configuration = base.isConfiguration();
  76         instance.constraints = base.getConstraints();
  77         instance.augmentations.addAll(base.getAvailableAugmentations());
  78
  79         URI ns = qname.getNamespace();
  80         Date rev = qname.getRevision();
  81         String pref = qname.getPrefix();
  82         addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
  83         addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
  84         addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
  85         addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
  86                 rev, pref));
  87
  88         instance.uses.addAll(base.getUses());
  89     }
  90
  91     @Override
  92     public ListSchemaNode build() {
  93         if (!isBuilt) {
  94             // CHILD NODES
  95             for (DataSchemaNodeBuilder node : addedChildNodes) {
  96                 childNodes.add(node.build());
  97             }
  98             instance.addChildNodes(childNodes);
  99
 100             // KEY
 101             if (keys == null) {
 102                 instance.keyDefinition = Collections.<QName> emptyList();
 103             } else {
 104                 List<QName> qnames = new ArrayList<>();
 105                 for (String key : keys) {
 106                     qnames.add(instance.getDataChildByName(key).getQName());
 107                 }
 108                 instance.keyDefinition = qnames;
 109             }
 110
 111             // TYPEDEFS
 112             for (TypeDefinitionBuilder entry : addedTypedefs) {
 113                 typedefs.add(entry.build());
 114             }
 115             instance.addTypeDefinitions(typedefs);
 116
 117             // USES
 118             for (UsesNodeBuilder builder : addedUsesNodes) {
 119                 usesNodes.add(builder.build());
 120             }
 121             instance.addUses(usesNodes);
 122
 123             // GROUPINGS
 124             for (GroupingBuilder builder : addedGroupings) {
 125                 groupings.add(builder.build());
 126             }
 127             instance.addGroupings(groupings);
 128
 129             // AUGMENTATIONS
 130             final Set<AugmentationSchema> augmentations = new HashSet<>();
 131             for (AugmentationSchemaBuilder builder : augmentationBuilders) {
 132                 augmentations.add(builder.build());
 133             }
 134             instance.addAvailableAugmentations(augmentations);
 135
 136             // UNKNOWN NODES
 137             for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
 138                 unknownNodes.add(b.build());
 139             }
 140             Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
 141             instance.addUnknownSchemaNodes(unknownNodes);
 142
 143             instance.setConstraints(constraints.build());
 144
 145             isBuilt = true;
 146         }
 147         return instance;
 148     }
 149
 150     @Override
 151     public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
 152         return addedTypedefs;
 153     }
 154
 155     @Override
 156     public void addTypedef(final TypeDefinitionBuilder type) {
 157         String typeName = type.getQName().getLocalName();
 158         for (TypeDefinitionBuilder addedTypedef : addedTypedefs) {
 159             if (addedTypedef.getQName().getLocalName().equals(typeName)) {
 160                 throw new YangParseException(moduleName, type.getLine(), "Can not add typedef '" + typeName
 161                         + "': typedef with same name already declared at line " + addedTypedef.getLine());
 162             }
 163         }
 164         addedTypedefs.add(type);
 165     }
 166
 167     @Override
 168     public SchemaPath getPath() {
 169         return instance.path;
 170     }
 171
 172     @Override
 173     public void setPath(final SchemaPath path) {
 174         instance.path = path;
 175     }
 176
 177     @Override
 178     public String getDescription() {
 179         return instance.description;
 180     }
 181
 182     @Override
 183     public void setDescription(final String description) {
 184         instance.description = description;
 185     }
 186
 187     @Override
 188     public String getReference() {
 189         return instance.reference;
 190     }
 191
 192     @Override
 193     public void setReference(final String reference) {
 194         instance.reference = reference;
 195     }
 196
 197     @Override
 198     public Status getStatus() {
 199         return instance.status;
 200     }
 201
 202     @Override
 203     public void setStatus(final Status status) {
 204         if (status != null) {
 205             instance.status = status;
 206         }
 207     }
 208
 209     @Override
 210     public void addAugmentation(final AugmentationSchemaBuilder augment) {
 211         augmentationBuilders.add(augment);
 212     }
 213
 214     public List<AugmentationSchemaBuilder> getAugmentationBuilders() {
 215         return augmentationBuilders;
 216     }
 217
 218     public List<String> getKeys() {
 219         return keys;
 220     }
 221
 222     public void setKeys(final List<String> keys) {
 223         this.keys = keys;
 224     }
 225
 226     @Override
 227     public boolean isAugmenting() {
 228         return instance.augmenting;
 229     }
 230
 231     @Override
 232     public void setAugmenting(final boolean augmenting) {
 233         instance.augmenting = augmenting;
 234     }
 235
 236     @Override
 237     public boolean isAddedByUses() {
 238         return instance.addedByUses;
 239     }
 240
 241     @Override
 242     public void setAddedByUses(final boolean addedByUses) {
 243         instance.addedByUses = addedByUses;
 244     }
 245
 246     @Override
 247     public boolean isConfiguration() {
 248         return instance.configuration;
 249     }
 250
 251     @Override
 252     public void setConfiguration(final boolean configuration) {
 253         instance.configuration = configuration;
 254     }
 255
 256     @Override
 257     public ConstraintsBuilder getConstraints() {
 258         return constraints;
 259     }
 260
 261     public boolean isUserOrdered() {
 262         return instance.userOrdered;
 263     }
 264
 265     public void setUserOrdered(final boolean userOrdered) {
 266         instance.userOrdered = userOrdered;
 267     }
 268
 269     @Override
 270     public int hashCode() {
 271         final int prime = 31;
 272         int result = 1;
 273         result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
 274         return result;
 275     }
 276
 277     @Override
 278     public boolean equals(final Object obj) {
 279         if (this == obj) {
 280             return true;
 281         }
 282         if (obj == null) {
 283             return false;
 284         }
 285         if (getClass() != obj.getClass()) {
 286             return false;
 287         }
 288         ListSchemaNodeBuilder other = (ListSchemaNodeBuilder) obj;
 289         if (schemaPath == null) {
 290             if (other.schemaPath != null) {
 291                 return false;
 292             }
 293         } else if (!schemaPath.equals(other.schemaPath)) {
 294             return false;
 295         }
 296         if (parentBuilder == null) {
 297             if (other.parentBuilder != null) {
 298                 return false;
 299             }
 300         } else if (!parentBuilder.equals(other.parentBuilder)) {
 301             return false;
 302         }
 303         return true;
 304     }
 305
 306     @Override
 307     public String toString() {
 308         return "list " + qname.getLocalName();
 309     }
 310
 311     private static final class ListSchemaNodeImpl implements ListSchemaNode {
 312         private final QName qname;
 313         private SchemaPath path;
 314         private String description;
 315         private String reference;
 316         private Status status = Status.CURRENT;
 317         private List<QName> keyDefinition = Collections.emptyList();
 318         private boolean augmenting;
 319         private boolean addedByUses;
 320         private boolean configuration;
 321         private ConstraintDefinition constraints;
 322         private final Set<AugmentationSchema> augmentations = new HashSet<>();
 323         private final Set<DataSchemaNode> childNodes = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
 324         private final Set<TypeDefinition<?>> typeDefinitions = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
 325         private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
 326         private final Set<UsesNode> uses = new HashSet<>();
 327         private boolean userOrdered;
 328         private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
 329
 330         private ListSchemaNodeImpl(final QName qname, final SchemaPath path) {
 331             this.qname = qname;
 332             this.path = path;
 333         }
 334
 335         @Override
 336         public QName getQName() {
 337             return qname;
 338         }
 339
 340         @Override
 341         public SchemaPath getPath() {
 342             return path;
 343         }
 344
 345         @Override
 346         public String getDescription() {
 347             return description;
 348         }
 349
 350         @Override
 351         public String getReference() {
 352             return reference;
 353         }
 354
 355         @Override
 356         public Status getStatus() {
 357             return status;
 358         }
 359
 360         @Override
 361         public List<QName> getKeyDefinition() {
 362             return keyDefinition;
 363         }
 364
 365         @Override
 366         public boolean isAugmenting() {
 367             return augmenting;
 368         }
 369
 370         @Override
 371         public boolean isAddedByUses() {
 372             return addedByUses;
 373         }
 374
 375         @Override
 376         public boolean isConfiguration() {
 377             return configuration;
 378         }
 379
 380         @Override
 381         public ConstraintDefinition getConstraints() {
 382             return constraints;
 383         }
 384
 385         private void setConstraints(final ConstraintDefinition constraints) {
 386             this.constraints = constraints;
 387         }
 388
 389         @Override
 390         public Set<AugmentationSchema> getAvailableAugmentations() {
 391             return Collections.unmodifiableSet(augmentations);
 392         }
 393
 394         private void addAvailableAugmentations(final Set<AugmentationSchema> augmentations) {
 395             if (augmentations != null) {
 396                 this.augmentations.addAll(augmentations);
 397             }
 398         }
 399
 400         @Override
 401         public Set<DataSchemaNode> getChildNodes() {
 402             return Collections.unmodifiableSet(childNodes);
 403         }
 404
 405         private void addChildNodes(final Set<DataSchemaNode> childNodes) {
 406             if (childNodes != null) {
 407                 this.childNodes.addAll(childNodes);
 408             }
 409         }
 410
 411         @Override
 412         public Set<GroupingDefinition> getGroupings() {
 413             return Collections.unmodifiableSet(groupings);
 414         }
 415
 416         private void addGroupings(final Set<GroupingDefinition> groupings) {
 417             if (groupings != null) {
 418                 this.groupings.addAll(groupings);
 419             }
 420         }
 421
 422         @Override
 423         public Set<TypeDefinition<?>> getTypeDefinitions() {
 424             return Collections.unmodifiableSet(typeDefinitions);
 425         }
 426
 427         private void addTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
 428             if (typeDefinitions != null) {
 429                 this.typeDefinitions.addAll(typeDefinitions);
 430             }
 431         }
 432
 433         @Override
 434         public Set<UsesNode> getUses() {
 435             return Collections.unmodifiableSet(uses);
 436         }
 437
 438         private void addUses(final Set<UsesNode> uses) {
 439             if (uses != null) {
 440                 this.uses.addAll(uses);
 441             }
 442         }
 443
 444         @Override
 445         public DataSchemaNode getDataChildByName(final QName name) {
 446             return getChildNode(childNodes, name);
 447         }
 448
 449         @Override
 450         public DataSchemaNode getDataChildByName(final String name) {
 451             return getChildNode(childNodes, name);
 452         }
 453
 454         @Override
 455         public boolean isUserOrdered() {
 456             return userOrdered;
 457         }
 458
 459         @Override
 460         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 461             return Collections.unmodifiableList(unknownNodes);
 462         }
 463
 464         private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
 465             if (unknownNodes != null) {
 466                 this.unknownNodes.addAll(unknownNodes);
 467             }
 468         }
 469
 470         @Override
 471         public int hashCode() {
 472             final int prime = 31;
 473             int result = 1;
 474             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 475             result = prime * result + ((path == null) ? 0 : path.hashCode());
 476             return result;
 477         }
 478
 479         @Override
 480         public boolean equals(final Object obj) {
 481             if (this == obj) {
 482                 return true;
 483             }
 484             if (obj == null) {
 485                 return false;
 486             }
 487             if (getClass() != obj.getClass()) {
 488                 return false;
 489             }
 490             final ListSchemaNodeImpl other = (ListSchemaNodeImpl) obj;
 491             if (qname == null) {
 492                 if (other.qname != null) {
 493                     return false;
 494                 }
 495             } else if (!qname.equals(other.qname)) {
 496                 return false;
 497             }
 498             if (path == null) {
 499                 if (other.path != null) {
 500                     return false;
 501                 }
 502             } else if (!path.equals(other.path)) {
 503                 return false;
 504             }
 505             return true;
 506         }
 507
 508         @Override
 509         public String toString() {
 510             return "list " + qname.getLocalName();
 511         }
 512     }
 513
 514 }