opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/model/parser/builder/ModuleBuilder.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.controller.model.parser.builder;\r
   9 \r
  10 import java.net.URI;\r
  11 import java.util.ArrayList;\r
  12 import java.util.Date;\r
  13 import java.util.HashMap;\r
  14 import java.util.HashSet;\r
  15 import java.util.List;\r
  16 import java.util.Map;\r
  17 import java.util.Set;\r
  18 import java.util.Stack;\r
  19 \r
  20 import org.opendaylight.controller.model.parser.api.AugmentationSchemaBuilder;\r
  21 import org.opendaylight.controller.model.parser.api.Builder;\r
  22 import org.opendaylight.controller.model.parser.api.ChildNodeBuilder;\r
  23 import org.opendaylight.controller.model.parser.api.DataSchemaNodeBuilder;\r
  24 import org.opendaylight.controller.model.parser.api.GroupingBuilder;\r
  25 import org.opendaylight.controller.model.parser.api.TypeAwareBuilder;\r
  26 import org.opendaylight.controller.model.parser.api.TypeDefinitionAwareBuilder;\r
  27 import org.opendaylight.controller.model.parser.api.TypeDefinitionBuilder;\r
  28 import org.opendaylight.controller.model.parser.api.UsesNodeBuilder;\r
  29 import org.opendaylight.controller.yang.common.QName;\r
  30 import org.opendaylight.controller.yang.model.api.AugmentationSchema;\r
  31 import org.opendaylight.controller.yang.model.api.DataSchemaNode;\r
  32 import org.opendaylight.controller.yang.model.api.Deviation;\r
  33 import org.opendaylight.controller.yang.model.api.FeatureDefinition;\r
  34 import org.opendaylight.controller.yang.model.api.GroupingDefinition;\r
  35 import org.opendaylight.controller.yang.model.api.Module;\r
  36 import org.opendaylight.controller.yang.model.api.ModuleImport;\r
  37 import org.opendaylight.controller.yang.model.api.NotificationDefinition;\r
  38 import org.opendaylight.controller.yang.model.api.RpcDefinition;\r
  39 import org.opendaylight.controller.yang.model.api.TypeDefinition;\r
  40 import org.opendaylight.controller.yang.model.api.UsesNode;\r
  41 \r
  42 \r
  43 /**\r
  44  * This builder builds Module object. If this module is dependent on external\r
  45  * module/modules, these dependencies must be resolved before module is built,\r
  46  * otherwise result may not be valid.\r
  47  */\r
  48 public class ModuleBuilder implements Builder {\r
  49 \r
  50         private final ModuleImpl instance;\r
  51         private final String name;\r
  52         private String prefix;\r
  53 \r
  54         private final Set<ModuleImport> imports = new HashSet<ModuleImport>();\r
  55         private Set<AugmentationSchema> augmentations;\r
  56 \r
  57         /**\r
  58          * All nodes, that can contain other nodes\r
  59          */\r
  60         private final Map<List<String>, Builder> moduleNodes = new HashMap<List<String>, Builder>();\r
  61 \r
  62         /**\r
  63          * Holds all child (DataSchemaNode) nodes: anyxml, choice, container, list, leaf, leaf-list.\r
  64          */\r
  65         private final Map<List<String>, DataSchemaNodeBuilder> addedChilds = new HashMap<List<String>, DataSchemaNodeBuilder>();\r
  66 \r
  67         private final Map<List<String>, GroupingBuilder> addedGroupings = new HashMap<List<String>, GroupingBuilder>();\r
  68         private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();\r
  69         private final Map<List<String>, UsesNodeBuilder> addedUsesNodes = new HashMap<List<String>, UsesNodeBuilder>();\r
  70         private final Map<List<String>, RpcDefinitionBuilder> addedRpcs = new HashMap<List<String>, RpcDefinitionBuilder>();\r
  71         private final Set<NotificationBuilder> addedNotifications = new HashSet<NotificationBuilder>();\r
  72         private final Map<List<String>, FeatureBuilder> addedFeatures = new HashMap<List<String>, FeatureBuilder>();\r
  73         private final Map<String, DeviationBuilder> addedDeviations = new HashMap<String, DeviationBuilder>();\r
  74         private final Map<List<String>, TypeDefinitionBuilder> addedTypedefs = new HashMap<List<String>, TypeDefinitionBuilder>();\r
  75 \r
  76 \r
  77         private final Map<List<String>, TypeAwareBuilder> dirtyNodes = new HashMap<List<String>, TypeAwareBuilder>();\r
  78 \r
  79 \r
  80         public ModuleBuilder(String name) {\r
  81                 this.name = name;\r
  82                 instance = new ModuleImpl(name);\r
  83         }\r
  84 \r
  85         /**\r
  86          * Build new Module object based on this builder. Throws IllegalStateException if builder contains unresolved nodes.\r
  87          */\r
  88         public Module build() {\r
  89                 instance.setImports(imports);\r
  90 \r
  91                 // TYPEDEFS\r
  92                 Set<TypeDefinition<?>> typedefs = buildModuleTypedefs(addedTypedefs);\r
  93                 instance.setTypeDefinitions(typedefs);\r
  94 \r
  95                 // CHILD NODES\r
  96                 final Map<QName, DataSchemaNode> childNodes = buildModuleChildNodes(addedChilds);\r
  97                 instance.setChildNodes(childNodes);\r
  98 \r
  99                 // GROUPINGS\r
 100                 final Set<GroupingDefinition> groupings = buildModuleGroupings(addedGroupings);\r
 101                 instance.setGroupings(groupings);\r
 102 \r
 103                 // USES\r
 104                 final Set<UsesNode> usesNodeDefinitions = buildUsesNodes(addedUsesNodes);\r
 105                 instance.setUses(usesNodeDefinitions);\r
 106 \r
 107                 // FEATURES\r
 108                 Set<FeatureDefinition> features = buildModuleFeatures(addedFeatures);\r
 109                 instance.setFeatures(features);\r
 110 \r
 111                 // NOTIFICATIONS\r
 112                 final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();\r
 113                 for (NotificationBuilder entry : addedNotifications) {\r
 114                         notifications.add((NotificationDefinition) entry.build());\r
 115                 }\r
 116                 instance.setNotifications(notifications);\r
 117 \r
 118                 // AUGMENTATIONS\r
 119 //              final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();\r
 120 //              for(AugmentationSchemaBuilder entry : addedAugments) {\r
 121 //                      augmentations.add(entry.build());\r
 122 //              }\r
 123 //              instance.setAugmentations(augmentations);\r
 124                 instance.setAugmentations(augmentations);\r
 125 \r
 126                 // RPCs\r
 127                 final Set<RpcDefinition> rpcs = buildModuleRpcs(addedRpcs);\r
 128                 instance.setRpcs(rpcs);\r
 129 \r
 130                 // DEVIATIONS\r
 131                 Set<Deviation> deviations = new HashSet<Deviation>();\r
 132                 for(Map.Entry<String, DeviationBuilder> entry : addedDeviations.entrySet()) {\r
 133                         deviations.add(entry.getValue().build());\r
 134                 }\r
 135                 instance.setDeviations(deviations);\r
 136 \r
 137                 return instance;\r
 138         }\r
 139 \r
 140         Builder getNode(List<String> path) {\r
 141                 return moduleNodes.get(path);\r
 142         }\r
 143 \r
 144         Map<List<String>, TypeAwareBuilder> getDirtyNodes() {\r
 145                 return dirtyNodes;\r
 146         }\r
 147 \r
 148         String getName() {\r
 149                 return name;\r
 150         }\r
 151 \r
 152         String getPrefix() {\r
 153                 return prefix;\r
 154         }\r
 155 \r
 156         Set<AugmentationSchemaBuilder> getAddedAugments() {\r
 157                 return addedAugments;\r
 158         }\r
 159 \r
 160 \r
 161         public void addDirtyNode(Stack<String> path) {\r
 162                 List<String> dirtyNodePath = new ArrayList<String>(path);\r
 163                 TypeAwareBuilder nodeBuilder = (TypeAwareBuilder)moduleNodes.get(dirtyNodePath);\r
 164                 dirtyNodes.put(dirtyNodePath, nodeBuilder);\r
 165         }\r
 166 \r
 167         public void setNamespace(URI namespace) {\r
 168                 instance.setNamespace(namespace);\r
 169         }\r
 170 \r
 171         public void setRevision(Date revision) {\r
 172                 instance.setRevision(revision);\r
 173         }\r
 174 \r
 175         public void setPrefix(String prefix) {\r
 176                 this.prefix = prefix;\r
 177                 instance.setPrefix(prefix);\r
 178         }\r
 179 \r
 180         public void setYangVersion(String yangVersion) {\r
 181                 instance.setYangVersion(yangVersion);\r
 182         }\r
 183 \r
 184         public void setDescription(String description) {\r
 185                 instance.setDescription(description);\r
 186         }\r
 187         public void setReference(String reference) {\r
 188                 instance.setReference(reference);\r
 189         }\r
 190         public void setOrganization(String organization) {\r
 191                 instance.setOrganization(organization);\r
 192         }\r
 193         public void setContact(String contact) {\r
 194                 instance.setContact(contact);\r
 195         }\r
 196         public void setAugmentations(Set<AugmentationSchema> augmentations) {\r
 197                 this.augmentations = augmentations;\r
 198         }\r
 199 \r
 200         public boolean addModuleImport(final String moduleName, final Date revision, final String prefix) {\r
 201                 ModuleImport moduleImport = createModuleImport(moduleName, revision, prefix);\r
 202                 return imports.add(moduleImport);\r
 203         }\r
 204 \r
 205         public Set<ModuleImport> getModuleImports() {\r
 206                 return imports;\r
 207         }\r
 208 \r
 209         public ContainerSchemaNodeBuilder addContainerNode(QName containerName, Stack<String> parentPath) {\r
 210                 List<String> pathToNode = new ArrayList<String>(parentPath);\r
 211 \r
 212                 ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(containerName);\r
 213 \r
 214                 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToNode);\r
 215                 if(parent != null) {\r
 216                         parent.addChildNode(containerBuilder);\r
 217                 }\r
 218 \r
 219                 pathToNode.add(containerName.getLocalName());\r
 220                 moduleNodes.put(pathToNode, containerBuilder);\r
 221                 addedChilds.put(pathToNode, containerBuilder);\r
 222 \r
 223                 return containerBuilder;\r
 224         }\r
 225 \r
 226         public ListSchemaNodeBuilder addListNode(QName listName, Stack<String> parentPath) {\r
 227                 List<String> pathToNode = new ArrayList<String>(parentPath);\r
 228 \r
 229                 ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(listName);\r
 230 \r
 231                 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToNode);\r
 232                 if(parent != null) {\r
 233                         parent.addChildNode(listBuilder);\r
 234                 }\r
 235 \r
 236                 pathToNode.add(listName.getLocalName());\r
 237                 moduleNodes.put(pathToNode, listBuilder);\r
 238                 addedChilds.put(pathToNode, listBuilder);\r
 239 \r
 240                 return listBuilder;\r
 241         }\r
 242 \r
 243         public LeafSchemaNodeBuilder addLeafNode(QName leafName, Stack<String> parentPath) {\r
 244                 List<String> pathToNode = new ArrayList<String>(parentPath);\r
 245 \r
 246                 LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(leafName);\r
 247 \r
 248                 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToNode);\r
 249                 if(parent != null) {\r
 250                         parent.addChildNode(leafBuilder);\r
 251                 }\r
 252 \r
 253                 pathToNode.add(leafName.getLocalName());\r
 254                 addedChilds.put(pathToNode, leafBuilder);\r
 255                 moduleNodes.put(pathToNode, leafBuilder);\r
 256 \r
 257                 return leafBuilder;\r
 258         }\r
 259 \r
 260         public LeafListSchemaNodeBuilder addLeafListNode(QName leafListName, Stack<String> parentPath) {\r
 261                 List<String> pathToNode = new ArrayList<String>(parentPath);\r
 262 \r
 263                 LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(leafListName);\r
 264                 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToNode);\r
 265                 if(parent != null) {\r
 266                         parent.addChildNode(leafListBuilder);\r
 267                 }\r
 268 \r
 269                 pathToNode.add(leafListName.getLocalName());\r
 270                 addedChilds.put(pathToNode, leafListBuilder);\r
 271                 moduleNodes.put(pathToNode, leafListBuilder);\r
 272 \r
 273                 return leafListBuilder;\r
 274         }\r
 275 \r
 276         public GroupingBuilder addGrouping(QName qname, Stack<String> parentPath) {\r
 277                 List<String> pathToGroup = new ArrayList<String>(parentPath);\r
 278 \r
 279                 GroupingBuilder builder = new GroupingBuilderImpl(qname);\r
 280                 ChildNodeBuilder parentNodeBuilder = (ChildNodeBuilder)moduleNodes.get(pathToGroup);\r
 281                 if(parentNodeBuilder != null) {\r
 282                         parentNodeBuilder.addGrouping(builder);\r
 283                 }\r
 284 \r
 285                 pathToGroup.add(qname.getLocalName());\r
 286                 moduleNodes.put(pathToGroup, builder);\r
 287                 addedGroupings.put(pathToGroup, builder);\r
 288 \r
 289                 return builder;\r
 290         }\r
 291 \r
 292         public AugmentationSchemaBuilder addAugment(String name, Stack<String> parentPath) {\r
 293                 List<String> pathToAugment = new ArrayList<String>(parentPath);\r
 294 \r
 295                 AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(name);\r
 296 \r
 297                 // augment can only be in 'module' or 'uses' statement\r
 298                 UsesNodeBuilder parent = addedUsesNodes.get(pathToAugment);\r
 299                 if(parent != null) {\r
 300                         parent.addAugment(builder);\r
 301                 }\r
 302 \r
 303                 pathToAugment.add(name);\r
 304                 moduleNodes.put(pathToAugment, builder);\r
 305                 addedAugments.add(builder);\r
 306 \r
 307                 return builder;\r
 308         }\r
 309 \r
 310         public UsesNodeBuilder addUsesNode(String groupingPathStr, Stack<String> parentPath) {\r
 311                 List<String> pathToUses = new ArrayList<String>(parentPath);\r
 312 \r
 313                 UsesNodeBuilder builder = new UsesNodeBuilderImpl(groupingPathStr);\r
 314 \r
 315                 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToUses);\r
 316                 if(parent != null) {\r
 317                         parent.addUsesNode(builder);\r
 318                 }\r
 319 \r
 320                 pathToUses.add(groupingPathStr);\r
 321                 addedUsesNodes.put(pathToUses, builder);\r
 322 \r
 323                 return builder;\r
 324         }\r
 325 \r
 326         public RpcDefinitionBuilder addRpc(QName qname, Stack<String> parentPath) {\r
 327                 List<String> pathToRpc = new ArrayList<String>(parentPath);\r
 328 \r
 329                 RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(qname);\r
 330 \r
 331                 pathToRpc.add(qname.getLocalName());\r
 332                 addedRpcs.put(pathToRpc, rpcBuilder);\r
 333 \r
 334                 QName inputQName = new QName(qname.getNamespace(), qname.getRevision(), qname.getPrefix(), "input");\r
 335                 ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(inputQName);\r
 336                 List<String> pathToInput = new ArrayList<String>(pathToRpc);\r
 337                 pathToInput.add("input");\r
 338                 moduleNodes.put(pathToInput, inputBuilder);\r
 339                 rpcBuilder.setInput(inputBuilder);\r
 340 \r
 341                 QName outputQName = new QName(qname.getNamespace(), qname.getRevision(), qname.getPrefix(), "output");\r
 342                 ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(outputQName);\r
 343                 List<String> pathToOutput = new ArrayList<String>(pathToRpc);\r
 344                 pathToOutput.add("output");\r
 345                 moduleNodes.put(pathToOutput, outputBuilder);\r
 346                 rpcBuilder.setOutput(outputBuilder);\r
 347 \r
 348                 return rpcBuilder;\r
 349         }\r
 350 \r
 351         public NotificationBuilder addNotification(QName notificationName, Stack<String> parentPath) {\r
 352                 List<String> pathToNotification = new ArrayList<String>(parentPath);\r
 353 \r
 354                 NotificationBuilder notificationBuilder = new NotificationBuilder(notificationName);\r
 355 \r
 356                 pathToNotification.add(notificationName.getLocalName());\r
 357                 moduleNodes.put(pathToNotification, notificationBuilder);\r
 358                 addedNotifications.add(notificationBuilder);\r
 359 \r
 360                 return notificationBuilder;\r
 361         }\r
 362 \r
 363         public FeatureBuilder addFeature(QName featureName, Stack<String> parentPath) {\r
 364                 List<String> pathToFeature = new ArrayList<String>(parentPath);\r
 365                 pathToFeature.add(featureName.getLocalName());\r
 366 \r
 367                 FeatureBuilder builder = new FeatureBuilder(featureName);\r
 368                 addedFeatures.put(pathToFeature, builder);\r
 369                 return builder;\r
 370         }\r
 371 \r
 372         public TypedefBuilder addTypedef(QName typeDefName, Stack<String> parentPath) {\r
 373                 List<String> pathToType = new ArrayList<String>(parentPath);\r
 374                 TypedefBuilder builder = new TypedefBuilder(typeDefName);\r
 375                 TypeDefinitionAwareBuilder parent = (TypeDefinitionAwareBuilder)moduleNodes.get(pathToType);\r
 376                 if(parent != null) {\r
 377                         parent.addTypedef(builder);\r
 378                 }\r
 379                 pathToType.add(typeDefName.getLocalName());\r
 380                 addedTypedefs.put(pathToType, builder);\r
 381                 moduleNodes.put(pathToType, builder);\r
 382                 return builder;\r
 383         }\r
 384 \r
 385         public Set<TypeDefinitionBuilder> getModuleTypedefs() {\r
 386                 Set<TypeDefinitionBuilder> typedefs = new HashSet<TypeDefinitionBuilder>();\r
 387                 for(Map.Entry<List<String>, TypeDefinitionBuilder> entry : addedTypedefs.entrySet()) {\r
 388                         if(entry.getKey().size() == 2) {\r
 389                                 typedefs.add(entry.getValue());\r
 390                         }\r
 391                 }\r
 392                 return typedefs;\r
 393         }\r
 394 \r
 395         public void setType(TypeDefinition<?> type, Stack<String> parentPath) {\r
 396                 TypeAwareBuilder parent = (TypeAwareBuilder)moduleNodes.get(parentPath);\r
 397                 parent.setType(type);\r
 398         }\r
 399 \r
 400         public DeviationBuilder addDeviation(String targetPath) {\r
 401                 DeviationBuilder builder = new DeviationBuilder(targetPath);\r
 402                 addedDeviations.put(targetPath, builder);\r
 403                 return builder;\r
 404         }\r
 405 \r
 406         public MustDefinitionBuilder addMustDefinition(String xpathStr, Stack<String> parentPath) {\r
 407                 MustAwareBuilder parent = (MustAwareBuilder)moduleNodes.get(parentPath);\r
 408                 String path = parentPath.get(parentPath.size()-1);\r
 409                 if(parent == null) {\r
 410                         for(Map.Entry<String, DeviationBuilder> db : addedDeviations.entrySet()) {\r
 411                                 String key = db.getKey();\r
 412                                 if(key.equals(path)) {\r
 413                                         parent = db.getValue();\r
 414                                 }\r
 415                         }\r
 416                 }\r
 417                 MustDefinitionBuilder builder = new MustDefinitionBuilder(xpathStr);\r
 418                 parent.setMustDefinitionBuilder(builder);\r
 419                 return builder;\r
 420         }\r
 421 \r
 422         public ModuleBuilder addSubmodule(QName qname) {\r
 423                 ModuleBuilder submoduleBuilder = new ModuleBuilder(qname.getLocalName());\r
 424                 return submoduleBuilder;\r
 425         }\r
 426 \r
 427 \r
 428 \r
 429         private class ModuleImpl implements Module {\r
 430 \r
 431         private URI namespace;\r
 432         private final String name;\r
 433         private Date revision;\r
 434         private String prefix;\r
 435         private String yangVersion;\r
 436         private String description;\r
 437         private String reference;\r
 438         private String organization;\r
 439         private String contact;\r
 440         private Set<ModuleImport> imports;\r
 441         private Set<FeatureDefinition> features;\r
 442         private Set<TypeDefinition<?>> typeDefinitions;\r
 443         private Set<NotificationDefinition> notifications;\r
 444         private Set<AugmentationSchema> augmentations;\r
 445         private Set<RpcDefinition> rpcs;\r
 446         private Set<Deviation> deviations;\r
 447         private Map<QName, DataSchemaNode> childNodes;\r
 448         private Set<GroupingDefinition> groupings;\r
 449         private Set<UsesNode> uses;\r
 450 \r
 451         private ModuleImpl(String name) {\r
 452                 this.name = name;\r
 453         }\r
 454 \r
 455 \r
 456         @Override\r
 457         public URI getNamespace() {\r
 458                 return namespace;\r
 459         }\r
 460         private void setNamespace(URI namespace) {\r
 461                 this.namespace = namespace;\r
 462         }\r
 463 \r
 464         @Override\r
 465         public String getName() {\r
 466                 return name;\r
 467         }\r
 468 \r
 469         @Override\r
 470         public Date getRevision() {\r
 471                 return revision;\r
 472         }\r
 473         private void setRevision(Date revision) {\r
 474                 this.revision = revision;\r
 475         }\r
 476 \r
 477         @Override\r
 478         public String getPrefix() {\r
 479                 return prefix;\r
 480         }\r
 481         private void setPrefix(String prefix) {\r
 482                 this.prefix = prefix;\r
 483         }\r
 484 \r
 485         @Override\r
 486         public String getYangVersion() {\r
 487                 return yangVersion;\r
 488         }\r
 489         private void setYangVersion(String yangVersion) {\r
 490                 this.yangVersion = yangVersion;\r
 491         }\r
 492 \r
 493         @Override\r
 494         public String getDescription() {\r
 495                 return description;\r
 496         }\r
 497         private void setDescription(String description) {\r
 498                 this.description = description;\r
 499         }\r
 500 \r
 501         @Override\r
 502         public String getReference() {\r
 503                 return reference;\r
 504         }\r
 505         private void setReference(String reference) {\r
 506                 this.reference = reference;\r
 507         }\r
 508 \r
 509         @Override\r
 510         public String getOrganization() {\r
 511                 return organization;\r
 512         }\r
 513         private void setOrganization(String organization) {\r
 514                 this.organization = organization;\r
 515         }\r
 516 \r
 517         @Override\r
 518         public String getContact() {\r
 519                 return contact;\r
 520         }\r
 521         private void setContact(String contact) {\r
 522                 this.contact = contact;\r
 523         }\r
 524 \r
 525         @Override\r
 526         public Set<ModuleImport> getImports() {\r
 527                 return imports;\r
 528         }\r
 529         private void setImports(Set<ModuleImport> imports) {\r
 530                 this.imports = imports;\r
 531         }\r
 532 \r
 533         @Override\r
 534         public Set<FeatureDefinition> getFeatures() {\r
 535                 return features;\r
 536         }\r
 537         private void setFeatures(Set<FeatureDefinition> features) {\r
 538                 this.features = features;\r
 539         }\r
 540 \r
 541         @Override\r
 542         public Set<TypeDefinition<?>> getTypeDefinitions() {\r
 543                 return typeDefinitions;\r
 544         }\r
 545         private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {\r
 546                 this.typeDefinitions = typeDefinitions;\r
 547         }\r
 548 \r
 549         @Override\r
 550         public Set<NotificationDefinition> getNotifications() {\r
 551                 return notifications;\r
 552         }\r
 553         private void setNotifications(Set<NotificationDefinition> notifications) {\r
 554                 this.notifications = notifications;\r
 555         }\r
 556 \r
 557         @Override\r
 558                 public Set<AugmentationSchema> getAugmentations() {\r
 559                         return augmentations;\r
 560                 }\r
 561         private void setAugmentations(Set<AugmentationSchema> augmentations) {\r
 562                         this.augmentations = augmentations;\r
 563                 }\r
 564 \r
 565         @Override\r
 566         public Set<RpcDefinition> getRpcs() {\r
 567                 return rpcs;\r
 568         }\r
 569         private void setRpcs(Set<RpcDefinition> rpcs) {\r
 570                 this.rpcs = rpcs;\r
 571         }\r
 572 \r
 573         @Override\r
 574         public Set<Deviation> getDeviations() {\r
 575                 return deviations;\r
 576         }\r
 577         private void setDeviations(Set<Deviation> deviations) {\r
 578                 this.deviations = deviations;\r
 579         }\r
 580 \r
 581         @Override\r
 582         public Set<DataSchemaNode> getChildNodes() {\r
 583                 return new HashSet<DataSchemaNode>(childNodes.values());\r
 584         }\r
 585         private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {\r
 586                 this.childNodes = childNodes;\r
 587         }\r
 588 \r
 589         @Override\r
 590         public Set<GroupingDefinition> getGroupings() {\r
 591                 return groupings;\r
 592         }\r
 593         private void setGroupings(Set<GroupingDefinition> groupings) {\r
 594                 this.groupings = groupings;\r
 595         }\r
 596 \r
 597         @Override\r
 598         public Set<UsesNode> getUses() {\r
 599                         return uses;\r
 600                 }\r
 601                 private void setUses(Set<UsesNode> uses) {\r
 602                         this.uses = uses;\r
 603                 }\r
 604 \r
 605         @Override\r
 606                 public DataSchemaNode getDataChildByName(QName name) {\r
 607                         return childNodes.get(name);\r
 608                 }\r
 609                 @Override\r
 610                 public DataSchemaNode getDataChildByName(String name) {\r
 611                         DataSchemaNode result = null;\r
 612                         for(Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {\r
 613                                 if(entry.getKey().getLocalName().equals(name)) {\r
 614                                         result = entry.getValue();\r
 615                                         break;\r
 616                                 }\r
 617                         }\r
 618                         return result;\r
 619                 }\r
 620 \r
 621                 @Override\r
 622                 public String toString() {\r
 623                         StringBuilder sb = new StringBuilder(ModuleImpl.class.getSimpleName());\r
 624                         sb.append("[\n");\r
 625                         sb.append("name="+ name +",\n");\r
 626                         sb.append("namespace="+ namespace +",\n");\r
 627                         sb.append("revision="+ revision +",\n");\r
 628                         sb.append("prefix="+ prefix +",\n");\r
 629                         sb.append("yangVersion="+ yangVersion +",\n");\r
 630                         sb.append("description="+ description +",\n");\r
 631                         sb.append("reference="+ reference +",\n");\r
 632                         sb.append("organization="+ organization +",\n");\r
 633                         sb.append("contact="+ contact +",\n");\r
 634                         sb.append("childNodes="+ childNodes.values() +",\n");\r
 635                         sb.append("groupings="+ groupings +",\n");\r
 636                         sb.append("imports="+ imports +",\n");\r
 637                         sb.append("features="+ features +",\n");\r
 638                         sb.append("typeDefinitions="+ typeDefinitions +",\n");\r
 639                         sb.append("notifications="+ notifications +",\n");\r
 640                         sb.append("augmentations="+ augmentations +",\n");\r
 641                         sb.append("rpcs="+ rpcs +",\n");\r
 642                         sb.append("deviations="+ deviations +"\n");\r
 643                         sb.append("]");\r
 644                         return sb.toString();\r
 645                 }\r
 646 \r
 647     }\r
 648 \r
 649         private ModuleImport createModuleImport(final String moduleName, final Date revision, final String prefix) {\r
 650                 ModuleImport moduleImport = new ModuleImport() {\r
 651                         @Override\r
 652                         public String getModuleName() {\r
 653                                 return moduleName;\r
 654                         }\r
 655                         @Override\r
 656                         public Date getRevision() {\r
 657                                 return revision;\r
 658                         }\r
 659                         @Override\r
 660                         public String getPrefix() {\r
 661                                 return prefix;\r
 662                         }\r
 663 \r
 664                         @Override\r
 665                         public int hashCode() {\r
 666                                 final int prime = 31;\r
 667                     int result = 1;\r
 668                     result = prime * result + ((moduleName == null) ? 0 : moduleName.hashCode());\r
 669                     result = prime * result + ((revision == null) ? 0 : revision.hashCode());\r
 670                     result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());\r
 671                     return result;\r
 672                         }\r
 673 \r
 674                         @Override\r
 675                 public boolean equals(Object obj) {\r
 676                     if (this == obj) {\r
 677                         return true;\r
 678                     }\r
 679                     if (obj == null) {\r
 680                         return false;\r
 681                     }\r
 682                     if (getClass() != obj.getClass()) {\r
 683                         return false;\r
 684                     }\r
 685                     ModuleImport other = (ModuleImport) obj;\r
 686                     if (getModuleName() == null) {\r
 687                         if (other.getModuleName() != null) {\r
 688                             return false;\r
 689                         }\r
 690                     } else if (!getModuleName().equals(other.getModuleName())) {\r
 691                         return false;\r
 692                     }\r
 693                     if (getRevision() == null) {\r
 694                         if (other.getRevision() != null) {\r
 695                             return false;\r
 696                         }\r
 697                     } else if (!getRevision().equals(other.getRevision())) {\r
 698                         return false;\r
 699                     }\r
 700                     if (getPrefix() == null) {\r
 701                         if (other.getPrefix() != null) {\r
 702                             return false;\r
 703                         }\r
 704                     } else if (!getPrefix().equals(other.getPrefix())) {\r
 705                         return false;\r
 706                     }\r
 707                     return true;\r
 708                 }\r
 709 \r
 710                         @Override\r
 711                         public String toString() {\r
 712                                 return "ModuleImport[moduleName="+ moduleName +", revision="+ revision +", prefix="+ prefix +"]";\r
 713                         }\r
 714                 };\r
 715                 return moduleImport;\r
 716         }\r
 717 \r
 718         /**\r
 719          * Traverse through given addedChilds and add only direct module childs. Direct\r
 720          * module child path size is 2 (1. module name, 2. child name).\r
 721          *\r
 722          * @param addedChilds\r
 723          * @return map of children, where key is child QName and value is child itself\r
 724          */\r
 725         private Map<QName, DataSchemaNode> buildModuleChildNodes(\r
 726                         Map<List<String>, DataSchemaNodeBuilder> addedChilds) {\r
 727                 final Map<QName, DataSchemaNode> childNodes = new HashMap<QName, DataSchemaNode>();\r
 728                 for (Map.Entry<List<String>, DataSchemaNodeBuilder> entry : addedChilds\r
 729                                 .entrySet()) {\r
 730                         if (entry.getKey().size() == 2) {\r
 731                                 DataSchemaNode node = entry.getValue().build();\r
 732                                 QName qname = entry.getValue().getQName();\r
 733                                 childNodes.put(qname, node);\r
 734                         }\r
 735                 }\r
 736                 return childNodes;\r
 737         }\r
 738 \r
 739         /**\r
 740          * Traverse through given addedGroupings and add only direct module groupings. Direct\r
 741          * module grouping path size is 2 (1. module name, 2. grouping name).\r
 742          *\r
 743          * @param addedGroupings\r
 744          * @return set of built GroupingDefinition objects\r
 745          */\r
 746         private Set<GroupingDefinition> buildModuleGroupings(Map<List<String>, GroupingBuilder> addedGroupings) {\r
 747                 final Set<GroupingDefinition> groupings = new HashSet<GroupingDefinition>();\r
 748                 for(Map.Entry<List<String>, GroupingBuilder> entry : addedGroupings.entrySet()) {\r
 749                         if(entry.getKey().size() == 2) {\r
 750                                 groupings.add(entry.getValue().build());\r
 751                         }\r
 752                 }\r
 753                 return groupings;\r
 754         }\r
 755 \r
 756         /**\r
 757          * Traverse through given addedRpcs and build RpcDefinition objects.\r
 758          * @param addedRpcs\r
 759          * @return set of built RpcDefinition objects\r
 760          */\r
 761         private Set<RpcDefinition> buildModuleRpcs(Map<List<String>, RpcDefinitionBuilder> addedRpcs) {\r
 762                 final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();\r
 763                 RpcDefinitionBuilder builder;\r
 764                 for(Map.Entry<List<String>, RpcDefinitionBuilder> entry : addedRpcs.entrySet()) {\r
 765                         builder = entry.getValue();\r
 766                         RpcDefinition rpc = builder.build();\r
 767                         rpcs.add(rpc);\r
 768                 }\r
 769                 return rpcs;\r
 770         }\r
 771 \r
 772         /**\r
 773          * Traverse through given addedTypedefs and add only direct module typedef statements. Direct\r
 774          * module typedef path size is 2 (1. module name, 2. typedef name).\r
 775          *\r
 776          * @param addedTypedefs\r
 777          * @return set of built module typedef statements\r
 778          */\r
 779         private Set<TypeDefinition<?>> buildModuleTypedefs(Map<List<String>, TypeDefinitionBuilder> addedTypedefs) {\r
 780                 Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();\r
 781                 for(Map.Entry<List<String>, TypeDefinitionBuilder> entry : addedTypedefs.entrySet()) {\r
 782                         if(entry.getKey().size() == 2) {\r
 783                                 TypeDefinition<? extends TypeDefinition<?>> node = entry.getValue().build();\r
 784                                 typedefs.add(node);\r
 785                         }\r
 786                 }\r
 787                 return typedefs;\r
 788         }\r
 789 \r
 790         /**\r
 791          * Traverse through given addedUsesNodes and add only direct module uses nodes. Direct\r
 792          * module uses node path size is 2 (1. module name, 2. uses name).\r
 793          *\r
 794          * @param addedUsesNodes\r
 795          * @return set of built module uses nodes\r
 796          */\r
 797         private Set<UsesNode> buildUsesNodes(Map<List<String>, UsesNodeBuilder> addedUsesNodes) {\r
 798                 final Set<UsesNode> usesNodeDefinitions = new HashSet<UsesNode>();\r
 799                 for (Map.Entry<List<String>, UsesNodeBuilder> entry : addedUsesNodes.entrySet()) {\r
 800                         if (entry.getKey().size() == 2) {\r
 801                                 usesNodeDefinitions.add(entry.getValue().build());\r
 802                         }\r
 803                 }\r
 804                 return usesNodeDefinitions;\r
 805         }\r
 806 \r
 807         /**\r
 808          * Traverse through given addedFeatures and add only direct module features. Direct\r
 809          * module feature path size is 2 (1. module name, 2. feature name).\r
 810          *\r
 811          * @param addedFeatures\r
 812          * @return set of built module features\r
 813          */\r
 814         private Set<FeatureDefinition> buildModuleFeatures(Map<List<String>, FeatureBuilder> addedFeatures) {\r
 815                 Set<FeatureDefinition> features = new HashSet<FeatureDefinition>();\r
 816                 for(Map.Entry<List<String>, FeatureBuilder> entry : addedFeatures.entrySet()) {\r
 817                         if(entry.getKey().size() == 2) {\r
 818                                 features.add((FeatureDefinition)entry.getValue().build());\r
 819                         }\r
 820                 }\r
 821                 return features;\r
 822         }\r
 823 \r
 824 }\r