yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/UsesNodeBuilderImpl.java

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