yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/UsesNodeBuilderImpl.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.util.ArrayList;
  11 import java.util.Collections;
  12 import java.util.HashMap;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Set;
  17
  18 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  19 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  20 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  21 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  22 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  23 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  26 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
  27 import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
  28 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  29 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
  30 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  31 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
  32 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
  33 import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
  34 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  35
  36 public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNodeBuilder {
  37     private boolean isBuilt;
  38     private UsesNodeImpl instance;
  39     private DataNodeContainerBuilder parent;
  40     private final String groupingName;
  41     private SchemaPath groupingPath;
  42     private GroupingDefinition groupingDefinition;
  43     private GroupingBuilder groupingBuilder;
  44     private boolean addedByUses;
  45     private boolean augmenting;
  46     private AugmentationSchemaBuilder parentAugment;
  47     private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();
  48     private final List<SchemaNodeBuilder> refineBuilders = new ArrayList<SchemaNodeBuilder>();
  49     private final List<RefineHolder> refines = new ArrayList<RefineHolder>();
  50
  51     private final Set<DataSchemaNodeBuilder> targetChildren = new HashSet<>();
  52     private final Set<GroupingBuilder> targetGroupings = new HashSet<>();
  53     private final Set<TypeDefinitionBuilder> targetTypedefs = new HashSet<>();
  54     private final List<UnknownSchemaNodeBuilder> targetUnknownNodes = new ArrayList<>();
  55
  56     private final boolean isCopy;
  57     private boolean dataCollected;
  58
  59     @Override
  60     public boolean isCopy() {
  61         return isCopy;
  62     }
  63
  64     @Override
  65     public boolean isDataCollected() {
  66         return dataCollected;
  67     }
  68
  69     @Override
  70     public void setDataCollected(boolean dataCollected) {
  71         this.dataCollected = dataCollected;
  72     }
  73
  74     public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName) {
  75         super(moduleName, line);
  76         this.groupingName = groupingName;
  77         isCopy = false;
  78     }
  79
  80     public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName, final boolean isCopy) {
  81         super(moduleName, line);
  82         this.groupingName = groupingName;
  83         this.isCopy = isCopy;
  84     }
  85
  86     @Override
  87     public UsesNode build() {
  88         if (!isBuilt) {
  89             instance = new UsesNodeImpl(groupingPath);
  90             instance.setAddedByUses(addedByUses);
  91
  92             // AUGMENTATIONS
  93             final Set<AugmentationSchema> augments = new HashSet<AugmentationSchema>();
  94             for (AugmentationSchemaBuilder builder : addedAugments) {
  95                 augments.add(builder.build());
  96             }
  97             instance.setAugmentations(augments);
  98
  99             // REFINES
 100             final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<SchemaPath, SchemaNode>();
 101             for (SchemaNodeBuilder refineBuilder : refineBuilders) {
 102                 SchemaNode refineNode = refineBuilder.build();
 103                 refineNodes.put(refineNode.getPath(), refineNode);
 104             }
 105             instance.setRefines(refineNodes);
 106
 107             // UNKNOWN NODES
 108             List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
 109             for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
 110                 unknownNodes.add(b.build());
 111             }
 112             instance.setUnknownSchemaNodes(unknownNodes);
 113
 114             isBuilt = true;
 115         }
 116
 117         return instance;
 118     }
 119
 120     @Override
 121     public DataNodeContainerBuilder getParent() {
 122         return parent;
 123     }
 124
 125     @Override
 126     public void setParent(Builder parent) {
 127         if (!(parent instanceof DataNodeContainerBuilder)) {
 128             throw new YangParseException(moduleName, line,
 129                     "Parent of 'uses' has to be instance of DataNodeContainerBuilder, but was: '" + parent + "'.");
 130         }
 131         this.parent = (DataNodeContainerBuilder) parent;
 132     }
 133
 134     @Override
 135     public SchemaPath getGroupingPath() {
 136         return groupingPath;
 137     }
 138
 139     @Override
 140     public GroupingDefinition getGroupingDefinition() {
 141         return groupingDefinition;
 142     }
 143
 144     @Override
 145     public void setGroupingDefinition(GroupingDefinition groupingDefinition) {
 146         this.groupingDefinition = groupingDefinition;
 147         if (groupingDefinition != null) {
 148             this.groupingPath = groupingDefinition.getPath();
 149         }
 150     }
 151
 152     @Override
 153     public GroupingBuilder getGroupingBuilder() {
 154         return groupingBuilder;
 155     }
 156
 157     @Override
 158     public void setGrouping(GroupingBuilder grouping) {
 159         this.groupingBuilder = grouping;
 160         if (groupingBuilder != null) {
 161             this.groupingPath = groupingBuilder.getPath();
 162         }
 163     }
 164
 165     @Override
 166     public String getGroupingPathAsString() {
 167         return groupingName;
 168     }
 169
 170     @Override
 171     public Set<AugmentationSchemaBuilder> getAugmentations() {
 172         return addedAugments;
 173     }
 174
 175     @Override
 176     public void addAugment(final AugmentationSchemaBuilder augmentBuilder) {
 177         addedAugments.add(augmentBuilder);
 178     }
 179
 180     @Override
 181     public boolean isAddedByUses() {
 182         return addedByUses;
 183     }
 184
 185     @Override
 186     public void setAddedByUses(final boolean addedByUses) {
 187         this.addedByUses = addedByUses;
 188     }
 189
 190     @Override
 191     public boolean isAugmenting() {
 192         return augmenting;
 193     }
 194
 195     @Override
 196     public void setAugmenting(boolean augmenting) {
 197         this.augmenting = augmenting;
 198     }
 199
 200     @Override
 201     public AugmentationSchemaBuilder getParentAugment() {
 202         return parentAugment;
 203     }
 204
 205     @Override
 206     public void setParentAugment(AugmentationSchemaBuilder augment) {
 207         this.parentAugment = augment;
 208     }
 209
 210     @Override
 211     public List<SchemaNodeBuilder> getRefineNodes() {
 212         return refineBuilders;
 213     }
 214
 215     @Override
 216     public void addRefineNode(DataSchemaNodeBuilder refineNode) {
 217         refineBuilders.add(refineNode);
 218     }
 219
 220     @Override
 221     public List<RefineHolder> getRefines() {
 222         return refines;
 223     }
 224
 225     @Override
 226     public void addRefine(RefineHolder refine) {
 227         refines.add(refine);
 228     }
 229
 230     @Override
 231     public Set<DataSchemaNodeBuilder> getTargetChildren() {
 232         return targetChildren;
 233     }
 234
 235     @Override
 236     public Set<GroupingBuilder> getTargetGroupings() {
 237         return targetGroupings;
 238     }
 239
 240     @Override
 241     public Set<TypeDefinitionBuilder> getTargetTypedefs() {
 242         return targetTypedefs;
 243     }
 244
 245     @Override
 246     public List<UnknownSchemaNodeBuilder> getTargetUnknownNodes() {
 247         return targetUnknownNodes;
 248     }
 249
 250     @Override
 251     public int hashCode() {
 252         final int prime = 31;
 253         int result = 1;
 254         result = prime * result + ((groupingName == null) ? 0 : groupingName.hashCode());
 255         result = prime * result + ((parent == null) ? 0 : parent.hashCode());
 256         return result;
 257     }
 258
 259     @Override
 260     public boolean equals(Object obj) {
 261         if (this == obj) {
 262             return true;
 263         }
 264         if (obj == null) {
 265             return false;
 266         }
 267         if (getClass() != obj.getClass()) {
 268             return false;
 269         }
 270         UsesNodeBuilderImpl other = (UsesNodeBuilderImpl) obj;
 271         if (groupingName == null) {
 272             if (other.groupingName != null) {
 273                 return false;
 274             }
 275         } else if (!groupingName.equals(other.groupingName)) {
 276             return false;
 277         }
 278         if (parent == null) {
 279             if (other.parent != null) {
 280                 return false;
 281             }
 282         } else if (!parent.equals(other.parent)) {
 283             return false;
 284         }
 285         return true;
 286     }
 287
 288     @Override
 289     public String toString() {
 290         return "uses '" + groupingName + "'";
 291     }
 292
 293     public final class UsesNodeImpl implements UsesNode {
 294         private final SchemaPath groupingPath;
 295         private Set<AugmentationSchema> augmentations = Collections.emptySet();
 296         private boolean addedByUses;
 297         private Map<SchemaPath, SchemaNode> refines = Collections.emptyMap();
 298         private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
 299
 300         private UsesNodeImpl(final SchemaPath groupingPath) {
 301             this.groupingPath = groupingPath;
 302         }
 303
 304         @Override
 305         public SchemaPath getGroupingPath() {
 306             return groupingPath;
 307         }
 308
 309         @Override
 310         public Set<AugmentationSchema> getAugmentations() {
 311             return augmentations;
 312         }
 313
 314         private void setAugmentations(final Set<AugmentationSchema> augmentations) {
 315             if (augmentations != null) {
 316                 this.augmentations = augmentations;
 317             }
 318         }
 319
 320         @Override
 321         public boolean isAugmenting() {
 322             return false;
 323         }
 324
 325         @Override
 326         public boolean isAddedByUses() {
 327             return addedByUses;
 328         }
 329
 330         private void setAddedByUses(final boolean addedByUses) {
 331             this.addedByUses = addedByUses;
 332         }
 333
 334         @Override
 335         public Map<SchemaPath, SchemaNode> getRefines() {
 336             return refines;
 337         }
 338
 339         private void setRefines(Map<SchemaPath, SchemaNode> refines) {
 340             if (refines != null) {
 341                 this.refines = refines;
 342             }
 343         }
 344
 345         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 346             return unknownNodes;
 347         }
 348
 349         private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
 350             if (unknownSchemaNodes != null) {
 351                 this.unknownNodes = unknownSchemaNodes;
 352             }
 353         }
 354
 355         public UsesNodeBuilder toBuilder() {
 356             return UsesNodeBuilderImpl.this;
 357         }
 358
 359         @Override
 360         public int hashCode() {
 361             final int prime = 31;
 362             int result = 1;
 363             result = prime * result + ((groupingPath == null) ? 0 : groupingPath.hashCode());
 364             result = prime * result + ((augmentations == null) ? 0 : augmentations.hashCode());
 365             return result;
 366         }
 367
 368         @Override
 369         public boolean equals(Object obj) {
 370             if (this == obj) {
 371                 return true;
 372             }
 373             if (obj == null) {
 374                 return false;
 375             }
 376             if (getClass() != obj.getClass()) {
 377                 return false;
 378             }
 379             final UsesNodeImpl other = (UsesNodeImpl) obj;
 380             if (groupingPath == null) {
 381                 if (other.groupingPath != null) {
 382                     return false;
 383                 }
 384             } else if (!groupingPath.equals(other.groupingPath)) {
 385                 return false;
 386             }
 387             if (augmentations == null) {
 388                 if (other.augmentations != null) {
 389                     return false;
 390                 }
 391             } else if (!augmentations.equals(other.augmentations)) {
 392                 return false;
 393             }
 394             return true;
 395         }
 396
 397         @Override
 398         public String toString() {
 399             StringBuilder sb = new StringBuilder(UsesNodeImpl.class.getSimpleName());
 400             sb.append("[groupingPath=");
 401             sb.append(groupingPath);
 402             sb.append("]");
 403             return sb.toString();
 404         }
 405     }
 406
 407 }