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> targetChildren = new HashSet<>();\r
  48     private final Set<GroupingBuilder> targetGroupings = new HashSet<>();\r
  49     private final Set<TypeDefinitionBuilder> targetTypedefs = new HashSet<>();\r
  50     private final List<UnknownSchemaNodeBuilder> targetUnknownNodes = new ArrayList<>();\r
  51 \r
  52     public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName) {\r
  53         super(moduleName, line);\r
  54         this.groupingName = groupingName;\r
  55     }\r
  56 \r
  57     public UsesNodeBuilderImpl(UsesNodeBuilder b) {\r
  58         super(b.getModuleName(), b.getLine());\r
  59         groupingName = b.getGroupingName();\r
  60         parent = b.getParent();\r
  61         groupingPath = b.getGroupingPath();\r
  62         augmenting = b.isAugmenting();\r
  63         addedByUses = b.isAddedByUses();\r
  64         addedAugments.addAll(b.getAugmentations());\r
  65         refineBuilders.addAll(b.getRefineNodes());\r
  66         refines.addAll(b.getRefines());\r
  67     }\r
  68 \r
  69     @Override\r
  70     public UsesNode build() {\r
  71         if (!isBuilt) {\r
  72             instance = new UsesNodeImpl(groupingPath);\r
  73             instance.setAugmenting(augmenting);\r
  74             instance.setAddedByUses(addedByUses);\r
  75 \r
  76             // AUGMENTATIONS\r
  77             final Set<AugmentationSchema> augments = new HashSet<AugmentationSchema>();\r
  78             for (AugmentationSchemaBuilder builder : addedAugments) {\r
  79                 augments.add(builder.build());\r
  80             }\r
  81             instance.setAugmentations(augments);\r
  82 \r
  83             // REFINES\r
  84             final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<SchemaPath, SchemaNode>();\r
  85             for (SchemaNodeBuilder refineBuilder : refineBuilders) {\r
  86                 SchemaNode refineNode = refineBuilder.build();\r
  87                 refineNodes.put(refineNode.getPath(), refineNode);\r
  88             }\r
  89             instance.setRefines(refineNodes);\r
  90 \r
  91             // UNKNOWN NODES\r
  92             List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();\r
  93             for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {\r
  94                 unknownNodes.add(b.build());\r
  95             }\r
  96             instance.setUnknownSchemaNodes(unknownNodes);\r
  97 \r
  98             isBuilt = true;\r
  99         }\r
 100         return instance;\r
 101     }\r
 102 \r
 103     @Override\r
 104     public DataNodeContainerBuilder getParent() {\r
 105         return parent;\r
 106     }\r
 107 \r
 108     @Override\r
 109     public void setParent(Builder parent) {\r
 110         if (!(parent instanceof DataNodeContainerBuilder)) {\r
 111             throw new YangParseException(moduleName, line, "Unresolved parent of uses '" + groupingName + "'.");\r
 112         }\r
 113         this.parent = (DataNodeContainerBuilder) parent;\r
 114     }\r
 115 \r
 116     @Override\r
 117     public SchemaPath getGroupingPath() {\r
 118         return groupingPath;\r
 119     }\r
 120 \r
 121     @Override\r
 122     public void setGroupingPath(SchemaPath groupingPath) {\r
 123         this.groupingPath = groupingPath;\r
 124     }\r
 125 \r
 126     @Override\r
 127     public String getGroupingName() {\r
 128         return groupingName;\r
 129     }\r
 130 \r
 131     @Override\r
 132     public Set<AugmentationSchemaBuilder> getAugmentations() {\r
 133         return addedAugments;\r
 134     }\r
 135 \r
 136     @Override\r
 137     public void addAugment(final AugmentationSchemaBuilder augmentBuilder) {\r
 138         addedAugments.add(augmentBuilder);\r
 139     }\r
 140 \r
 141     @Override\r
 142     public boolean isAugmenting() {\r
 143         return augmenting;\r
 144     }\r
 145 \r
 146     @Override\r
 147     public void setAugmenting(final boolean augmenting) {\r
 148         this.augmenting = augmenting;\r
 149     }\r
 150 \r
 151     @Override\r
 152     public boolean isAddedByUses() {\r
 153         return addedByUses;\r
 154     }\r
 155 \r
 156     @Override\r
 157     public void setAddedByUses(final boolean addedByUses) {\r
 158         this.addedByUses = addedByUses;\r
 159     }\r
 160 \r
 161     @Override\r
 162     public List<SchemaNodeBuilder> getRefineNodes() {\r
 163         return refineBuilders;\r
 164     }\r
 165 \r
 166     @Override\r
 167     public void addRefineNode(DataSchemaNodeBuilder refineNode) {\r
 168         // add to refine nodes\r
 169         refineBuilders.add(refineNode);\r
 170         // replace in target children\r
 171         DataSchemaNodeBuilder toRemove = null;\r
 172         for(DataSchemaNodeBuilder child : targetChildren) {\r
 173             if(child.getQName().equals(refineNode.getQName())) {\r
 174                 toRemove = child;\r
 175                 break;\r
 176             }\r
 177         }\r
 178         targetChildren.remove(toRemove);\r
 179         targetChildren.add(refineNode);\r
 180     }\r
 181 \r
 182     @Override\r
 183     public List<RefineHolder> getRefines() {\r
 184         return refines;\r
 185     }\r
 186 \r
 187     @Override\r
 188     public void addRefine(RefineHolder refine) {\r
 189         refines.add(refine);\r
 190     }\r
 191 \r
 192     @Override\r
 193     public Set<DataSchemaNodeBuilder> getTargetChildren() {\r
 194         return targetChildren;\r
 195     }\r
 196 \r
 197     @Override\r
 198     public Set<GroupingBuilder> getTargetGroupings() {\r
 199         return targetGroupings;\r
 200     }\r
 201 \r
 202     @Override\r
 203     public Set<TypeDefinitionBuilder> getTargetTypedefs() {\r
 204         return targetTypedefs;\r
 205     }\r
 206 \r
 207     @Override\r
 208     public List<UnknownSchemaNodeBuilder> getTargetUnknownNodes() {\r
 209         return targetUnknownNodes;\r
 210     }\r
 211 \r
 212     @Override\r
 213     public int hashCode() {\r
 214         final int prime = 31;\r
 215         int result = 1;\r
 216         result = prime * result + ((groupingName == null) ? 0 : groupingName.hashCode());\r
 217         return result;\r
 218     }\r
 219 \r
 220     @Override\r
 221     public boolean equals(Object obj) {\r
 222         if (this == obj)\r
 223             return true;\r
 224         if (obj == null)\r
 225             return false;\r
 226         if (getClass() != obj.getClass())\r
 227             return false;\r
 228         UsesNodeBuilderImpl other = (UsesNodeBuilderImpl) obj;\r
 229         if (groupingName == null) {\r
 230             if (other.groupingName != null)\r
 231                 return false;\r
 232         } else if (!groupingName.equals(other.groupingName))\r
 233             return false;\r
 234 \r
 235         if (parent == null) {\r
 236             if (other.parent != null)\r
 237                 return false;\r
 238         } else if (!parent.equals(other.parent))\r
 239             return false;\r
 240         if (refines == null) {\r
 241             if (other.refines != null)\r
 242                 return false;\r
 243         } else if (!refines.equals(other.refines))\r
 244             return false;\r
 245         return true;\r
 246     }\r
 247 \r
 248     @Override\r
 249     public String toString() {\r
 250         return "uses '" + groupingName + "'";\r
 251     }\r
 252 \r
 253     public final class UsesNodeImpl implements UsesNode {\r
 254         private final SchemaPath groupingPath;\r
 255         private Set<AugmentationSchema> augmentations = Collections.emptySet();\r
 256         private boolean augmenting;\r
 257         private boolean addedByUses;\r
 258         private Map<SchemaPath, SchemaNode> refines = Collections.emptyMap();\r
 259         private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();\r
 260 \r
 261         private UsesNodeImpl(final SchemaPath groupingPath) {\r
 262             this.groupingPath = groupingPath;\r
 263         }\r
 264 \r
 265         @Override\r
 266         public SchemaPath getGroupingPath() {\r
 267             return groupingPath;\r
 268         }\r
 269 \r
 270         @Override\r
 271         public Set<AugmentationSchema> getAugmentations() {\r
 272             return augmentations;\r
 273         }\r
 274 \r
 275         private void setAugmentations(final Set<AugmentationSchema> augmentations) {\r
 276             if (augmentations != null) {\r
 277                 this.augmentations = augmentations;\r
 278             }\r
 279         }\r
 280 \r
 281         @Override\r
 282         public boolean isAugmenting() {\r
 283             return augmenting;\r
 284         }\r
 285 \r
 286         private void setAugmenting(final boolean augmenting) {\r
 287             this.augmenting = augmenting;\r
 288         }\r
 289 \r
 290         @Override\r
 291         public boolean isAddedByUses() {\r
 292             return addedByUses;\r
 293         }\r
 294 \r
 295         private void setAddedByUses(final boolean addedByUses) {\r
 296             this.addedByUses = addedByUses;\r
 297         }\r
 298 \r
 299         @Override\r
 300         public Map<SchemaPath, SchemaNode> getRefines() {\r
 301             return refines;\r
 302         }\r
 303 \r
 304         private void setRefines(Map<SchemaPath, SchemaNode> refines) {\r
 305             if (refines != null) {\r
 306                 this.refines = refines;\r
 307             }\r
 308         }\r
 309 \r
 310         public List<UnknownSchemaNode> getUnknownSchemaNodes() {\r
 311             return unknownNodes;\r
 312         }\r
 313 \r
 314         private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {\r
 315             if (unknownSchemaNodes != null) {\r
 316                 this.unknownNodes = unknownSchemaNodes;\r
 317             }\r
 318         }\r
 319 \r
 320         public UsesNodeBuilder toBuilder() {\r
 321             return UsesNodeBuilderImpl.this;\r
 322         }\r
 323 \r
 324         @Override\r
 325         public int hashCode() {\r
 326             final int prime = 31;\r
 327             int result = 1;\r
 328             result = prime * result + ((groupingPath == null) ? 0 : groupingPath.hashCode());\r
 329             result = prime * result + ((augmentations == null) ? 0 : augmentations.hashCode());\r
 330             result = prime * result + (augmenting ? 1231 : 1237);\r
 331             return result;\r
 332         }\r
 333 \r
 334         @Override\r
 335         public boolean equals(Object obj) {\r
 336             if (this == obj) {\r
 337                 return true;\r
 338             }\r
 339             if (obj == null) {\r
 340                 return false;\r
 341             }\r
 342             if (getClass() != obj.getClass()) {\r
 343                 return false;\r
 344             }\r
 345             final UsesNodeImpl other = (UsesNodeImpl) obj;\r
 346             if (groupingPath == null) {\r
 347                 if (other.groupingPath != null) {\r
 348                     return false;\r
 349                 }\r
 350             } else if (!groupingPath.equals(other.groupingPath)) {\r
 351                 return false;\r
 352             }\r
 353             if (augmentations == null) {\r
 354                 if (other.augmentations != null) {\r
 355                     return false;\r
 356                 }\r
 357             } else if (!augmentations.equals(other.augmentations)) {\r
 358                 return false;\r
 359             }\r
 360             if (augmenting != other.augmenting) {\r
 361                 return false;\r
 362             }\r
 363             return true;\r
 364         }\r
 365 \r
 366         @Override\r
 367         public String toString() {\r
 368             StringBuilder sb = new StringBuilder(UsesNodeImpl.class.getSimpleName());\r
 369             sb.append("[groupingPath=" + groupingPath + "]");\r
 370             return sb.toString();\r
 371         }\r
 372     }\r
 373 \r
 374 }\r