binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/YangTemplate.xtend

   1 /*
   2  * Copyright (c) 2014 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.mdsal.binding.generator.impl
   9
  10 import java.util.Collection
  11 import java.util.List
  12 import java.util.Map
  13 import java.util.Set
  14 import org.opendaylight.yangtools.yang.common.Revision
  15 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode
  16 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode
  17 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode
  18 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode
  19 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode
  20 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
  21 import org.opendaylight.yangtools.yang.model.api.Deviation
  22 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition
  23 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition
  24 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition
  25 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode
  26 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode
  27 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode
  28 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode
  29 import org.opendaylight.yangtools.yang.model.api.Module
  30 import org.opendaylight.yangtools.yang.model.api.ModuleImport
  31 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition
  32 import org.opendaylight.yangtools.yang.model.api.RpcDefinition
  33 import org.opendaylight.yangtools.yang.model.api.SchemaNode
  34 import org.opendaylight.yangtools.yang.model.api.SchemaPath
  35 import org.opendaylight.yangtools.yang.model.api.Status
  36 import org.opendaylight.yangtools.yang.model.api.TypeDefinition
  37 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode
  38 import org.opendaylight.yangtools.yang.model.api.UsesNode
  39 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition
  40 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair
  41
  42 class YangTemplate {
  43
  44     private static val String SKIP_PROPERTY_NAME = "mdsal.skip.verbose"
  45
  46     private static val SKIP = Boolean.getBoolean(SKIP_PROPERTY_NAME)
  47
  48     private static val SKIPPED_EMPTY = '''(Empty due to «SKIP_PROPERTY_NAME» property = true)'''
  49
  50     def static String generateYangSnipet(SchemaNode schemaNode) {
  51         if (schemaNode === null)
  52             return ''
  53         if (SKIP)
  54             return SKIPPED_EMPTY
  55         '''
  56             «IF schemaNode instanceof DataSchemaNode»
  57             «writeDataSchemaNode(schemaNode)»
  58             «ENDIF»
  59             «IF schemaNode instanceof EnumTypeDefinition.EnumPair»
  60             «writeEnumPair(schemaNode)»
  61             «ENDIF»
  62             «IF schemaNode instanceof ExtensionDefinition»
  63             «writeExtension(schemaNode)»
  64             «ENDIF»
  65             «IF schemaNode instanceof FeatureDefinition»
  66             «writeFeature(schemaNode)»
  67             «ENDIF»
  68             «IF schemaNode instanceof GroupingDefinition»
  69             «writeGroupingDef(schemaNode)»
  70             «ENDIF»
  71             «IF schemaNode instanceof IdentitySchemaNode»
  72             «writeIdentity(schemaNode)»
  73             «ENDIF»
  74             «IF schemaNode instanceof NotificationDefinition»
  75             «writeNotification(schemaNode)»
  76             «ENDIF»
  77             «IF schemaNode instanceof RpcDefinition»
  78             «writeRPC(schemaNode)»
  79             «ENDIF»
  80             «IF schemaNode instanceof TypeDefinition<?>»
  81             «writeTypeDefinition(schemaNode)»
  82             «ENDIF»
  83             «IF schemaNode instanceof UnknownSchemaNode»
  84             «writeUnknownSchemaNode(schemaNode)»
  85             «ENDIF»
  86         '''
  87     }
  88
  89     def static String generateYangSnipet(Set<? extends SchemaNode> nodes) {
  90         if (nodes.nullOrEmpty)
  91             return ''
  92         if (SKIP)
  93             return SKIPPED_EMPTY
  94         '''
  95             «FOR node : nodes»
  96                 «IF node instanceof NotificationDefinition»
  97                 «writeNotification(node)»
  98                 «ELSEIF node instanceof RpcDefinition»
  99                 «writeRPC(node)»
 100                 «ENDIF»
 101             «ENDFOR»
 102         '''
 103     }
 104
 105     def private static writeEnumPair(EnumPair pair) {
 106         '''
 107             enum «pair.name» {
 108                 value «pair.value»;
 109             }
 110         '''
 111     }
 112
 113     def private static String writeModuleImports(Set<ModuleImport> moduleImports) {
 114         if (moduleImports.nullOrEmpty)
 115             return ''
 116
 117         '''
 118             «FOR moduleImport : moduleImports SEPARATOR "\n"»
 119                 «IF moduleImport !== null && !moduleImport.moduleName.nullOrEmpty»
 120                 import «moduleImport.moduleName» { prefix "«moduleImport.prefix»"; }
 121                 «ENDIF»
 122             «ENDFOR»
 123         '''
 124     }
 125
 126     def private static writeRevision(Revision moduleRevision, String moduleDescription) {
 127         val revisionIndent = 12
 128
 129         '''
 130             revision «moduleRevision.toString» {
 131                 description "«YangTextTemplate.formatToParagraph(moduleDescription, revisionIndent)»";
 132             }
 133         '''
 134     }
 135
 136     def static String generateYangSnipet(Module module) {
 137         if (SKIP)
 138             return SKIPPED_EMPTY
 139         '''
 140             module «module.name» {
 141                 yang-version «module.yangVersion»;
 142                 namespace "«module.QNameModule.namespace.toString»";
 143                 prefix "«module.prefix»";
 144
 145                 «IF !module.imports.nullOrEmpty»
 146                 «writeModuleImports(module.imports)»
 147                 «ENDIF»
 148                 «IF module.revision.present»
 149                 «writeRevision(module.revision.get, module.description.orElse(null))»
 150                 «ENDIF»
 151                 «IF !module.childNodes.nullOrEmpty»
 152
 153                 «writeDataSchemaNodes(module.childNodes)»
 154                 «ENDIF»
 155                 «IF !module.groupings.nullOrEmpty»
 156
 157                 «writeGroupingDefs(module.groupings)»
 158                 «ENDIF»
 159                 «IF !module.augmentations.nullOrEmpty»
 160
 161                 «writeAugments(module.augmentations)»
 162                 «ENDIF»
 163                 «IF !module.deviations.nullOrEmpty»
 164
 165                 «writeDeviations(module.deviations)»
 166                 «ENDIF»
 167                 «IF !module.extensionSchemaNodes.nullOrEmpty»
 168
 169                 «writeExtensions(module.extensionSchemaNodes)»
 170                 «ENDIF»
 171                 «IF !module.features.nullOrEmpty»
 172
 173                 «writeFeatures(module.features)»
 174                 «ENDIF»
 175                 «IF !module.identities.nullOrEmpty»
 176
 177                 «writeIdentities(module.identities)»
 178                 «ENDIF»
 179                 «IF !module.notifications.nullOrEmpty»
 180
 181                 «writeNotifications(module.notifications)»
 182                 «ENDIF»
 183                 «IF !module.rpcs.nullOrEmpty»
 184
 185                 «writeRPCs(module.rpcs)»
 186                 «ENDIF»
 187                 «IF !module.unknownSchemaNodes.nullOrEmpty»
 188
 189                 «writeUnknownSchemaNodes(module.unknownSchemaNodes)»
 190                 «ENDIF»
 191                 «IF !module.uses.nullOrEmpty»
 192
 193                 «writeUsesNodes(module.uses)»
 194                 «ENDIF»
 195             }
 196         '''
 197     }
 198
 199     def private static writeRPCs(Set<RpcDefinition> rpcDefs) {
 200         '''
 201             «FOR rpc : rpcDefs»
 202                 «IF rpc !== null»
 203                 «writeRPC(rpc)»
 204                 «ENDIF»
 205             «ENDFOR»
 206         '''
 207     }
 208
 209     def private static writeRPC(RpcDefinition rpc) {
 210         var boolean isStatusDeprecated = rpc.status == Status::DEPRECATED
 211         '''
 212             rpc «rpc.QName.localName» {
 213                 «IF rpc.description.present»
 214                     "«rpc.description.get»";
 215                 «ENDIF»
 216                 «IF !rpc.groupings.nullOrEmpty»
 217                     «writeGroupingDefs(rpc.groupings)»
 218                 «ENDIF»
 219                 «IF rpc.input !== null»
 220                     «writeRpcInput(rpc.input)»
 221                 «ENDIF»
 222                 «IF rpc.output !== null»
 223                     «writeRpcOutput(rpc.output)»
 224                 «ENDIF»
 225                 «IF rpc.reference.present»
 226                 reference
 227                     "«rpc.reference.get»";
 228                 «ENDIF»
 229                 «IF isStatusDeprecated»
 230                 status «rpc.status»;
 231                 «ENDIF»
 232             }
 233         '''
 234     }
 235
 236     def private static writeRpcInput(ContainerSchemaNode input) {
 237         if (input === null)
 238             return ''
 239
 240         '''
 241             input {
 242                 «IF !input.childNodes.nullOrEmpty»
 243                 «writeDataSchemaNodes(input.childNodes)»
 244                 «ENDIF»
 245             }
 246
 247         '''
 248     }
 249
 250     def private static writeRpcOutput(ContainerSchemaNode output) {
 251         if (output === null)
 252             return ''
 253
 254         '''
 255             output {
 256                 «IF !output.childNodes.nullOrEmpty»
 257                 «writeDataSchemaNodes(output.childNodes)»
 258                 «ENDIF»
 259             }
 260         '''
 261     }
 262
 263     def private static writeNotifications(Set<NotificationDefinition> notifications) {
 264         '''
 265             «FOR notification : notifications»
 266                 «IF notification !== null»
 267                 «writeNotification(notification)»
 268                 «ENDIF»
 269             «ENDFOR»
 270         '''
 271     }
 272
 273     def private static writeNotification(NotificationDefinition notification) {
 274         var boolean isStatusDeprecated = notification.status == Status::DEPRECATED
 275         '''
 276             notification «notification.QName.localName» {
 277                 «IF notification.description.present»
 278                 description
 279                     "«notification.description.get»";
 280                 «ENDIF»
 281                 «IF !notification.childNodes.nullOrEmpty»
 282                     «writeDataSchemaNodes(notification.childNodes)»
 283                 «ENDIF»
 284                 «IF !notification.availableAugmentations.nullOrEmpty»
 285                     «writeAugments(notification.availableAugmentations)»
 286                 «ENDIF»
 287                 «IF !notification.groupings.nullOrEmpty»
 288                     «writeGroupingDefs(notification.groupings)»
 289                 «ENDIF»
 290                 «IF !notification.uses.nullOrEmpty»
 291                     «writeUsesNodes(notification.uses)»
 292                 «ENDIF»
 293                 «IF notification.reference.present»
 294                 reference
 295                     "«notification.reference.get»";
 296                 «ENDIF»
 297                 «IF isStatusDeprecated»
 298                 status «notification.status»;
 299                 «ENDIF»
 300             }
 301         '''
 302     }
 303
 304     def private static writeUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
 305         if (unknownSchemaNodes.nullOrEmpty)
 306             return ''
 307
 308         '''
 309             «FOR unknownSchemaNode : unknownSchemaNodes»
 310                 «writeUnknownSchemaNode(unknownSchemaNode)»
 311             «ENDFOR»
 312         '''
 313     }
 314
 315     def private static writeUnknownSchemaNode(UnknownSchemaNode unknownSchemaNode) {
 316         return ''
 317     }
 318
 319     def private static writeUsesNodes(Set<UsesNode> usesNodes) {
 320         if (usesNodes === null) {
 321             return ''
 322         }
 323
 324         '''
 325             «FOR usesNode : usesNodes»
 326                 «IF usesNode !== null»
 327                 «writeUsesNode(usesNode)»
 328                 «ENDIF»
 329             «ENDFOR»
 330         '''
 331     }
 332
 333     def private static writeUsesNode(UsesNode usesNode) {
 334         val hasRefines = !usesNode.refines.empty
 335
 336         '''
 337             uses «usesNode.groupingPath.pathFromRoot.head.localName»«IF !hasRefines»;«ELSE» {«ENDIF»
 338             «IF hasRefines»
 339                 «writeRefines(usesNode.refines)»
 340             }
 341             «ENDIF»
 342         '''
 343     }
 344
 345     def private static writeRefines(Map<SchemaPath, SchemaNode> refines) {
 346         '''
 347             «FOR path : refines.keySet»
 348             «val schemaNode = refines.get(path)»
 349             «writeRefine(path, schemaNode)»
 350             «ENDFOR»
 351         '''
 352     }
 353
 354     def private static writeRefine(SchemaPath path, SchemaNode schemaNode) {
 355         '''
 356             refine «path.pathFromRoot.last» {
 357                 «IF schemaNode instanceof DataSchemaNode»
 358                 «writeDataSchemaNode(schemaNode)»
 359                 «ENDIF»
 360             }
 361         '''
 362     }
 363
 364     def private static writeTypeDefinition(TypeDefinition<?> typeDefinition) {
 365         var boolean isStatusDeprecated = typeDefinition.status == Status::DEPRECATED
 366         '''
 367             type «typeDefinition.QName.localName»«IF !isStatusDeprecated»;«ELSE» {
 368                 status «typeDefinition.status»;
 369             }
 370             «ENDIF»
 371         '''
 372     }
 373
 374     def private static writeIdentities(Set<IdentitySchemaNode> identities) {
 375         if (identities.nullOrEmpty)
 376             return ''
 377         '''
 378             «FOR identity : identities»
 379                 «writeIdentity(identity)»
 380             «ENDFOR»
 381         '''
 382     }
 383
 384     def private static writeIdentity(IdentitySchemaNode identity) {
 385         if (identity === null)
 386             return ''
 387         '''
 388             identity «identity.QName.localName» {
 389                 «FOR baseIdentity : identity.baseIdentities»
 390                 base "()«baseIdentity»";
 391                 «ENDFOR»
 392                 «IF identity.description.present»
 393                 description
 394                     "«identity.description.get»";
 395                 «ENDIF»
 396                 «IF identity.reference.present»
 397                 reference
 398                     "«identity.reference.get»";
 399                 «ENDIF»
 400                 «IF identity.status !== null»
 401                 status «identity.status»;
 402                 «ENDIF»
 403             }
 404         '''
 405     }
 406
 407     def private static writeFeatures(Set<FeatureDefinition> features) {
 408         '''
 409             «FOR feature : features»
 410                 «IF feature !== null»
 411                 «writeFeature(feature)»
 412                 «ENDIF»
 413             «ENDFOR»
 414         '''
 415     }
 416
 417     def private static writeFeature(FeatureDefinition featureDef) {
 418         '''
 419             feature «featureDef.QName.localName» {
 420                 «IF featureDef.description.present»
 421                 description
 422                     "«featureDef.description.get»";
 423                 «ENDIF»
 424                 «IF featureDef.reference.present»
 425                 reference
 426                     "«featureDef.reference.get»";
 427                 «ENDIF»
 428                 «IF featureDef.status !== null»
 429                 status «featureDef.status»;
 430                 «ENDIF»
 431             }
 432         '''
 433     }
 434
 435     def private static writeExtensions(List<ExtensionDefinition> extensions) {
 436         '''
 437             «FOR anExtension : extensions»
 438                 «IF anExtension !== null»
 439                 «writeExtension(anExtension)»
 440                 «ENDIF»
 441             «ENDFOR»
 442         '''
 443     }
 444
 445     def private static writeExtension(ExtensionDefinition extensionDef) {
 446         '''
 447             extension «extensionDef.QName.localName» {
 448                 «IF extensionDef.description.present»
 449                 description
 450                     "«extensionDef.description.get»";
 451                 «ENDIF»
 452                 «IF !extensionDef.argument.nullOrEmpty»
 453                 argument "«extensionDef.argument»";
 454                 «ENDIF»
 455                 «IF extensionDef.reference.present»
 456                 reference
 457                     "«extensionDef.reference.get»";
 458                 «ENDIF»
 459                 «IF extensionDef.status !== null»
 460                 status «extensionDef.status»;
 461                 «ENDIF»
 462             }
 463         '''
 464     }
 465
 466     def private static writeDeviations(Set<Deviation> deviations) {
 467         '''
 468             «FOR deviation : deviations»
 469                 «IF deviation !== null»
 470                 «writeDeviation(deviation)»
 471                 «ENDIF»
 472             «ENDFOR»
 473         '''
 474     }
 475
 476     def private static writeDeviation(Deviation deviation) {
 477         '''
 478             deviation «deviation.targetPath» {
 479                 «IF deviation.reference.present»
 480                     reference
 481                         "«deviation.reference.get»";
 482                 «ENDIF»
 483                 «FOR dev : deviation.deviates»
 484                     «IF dev !== null && dev.deviateType !== null»
 485                         deviation «dev.deviateType.name»;
 486                     «ENDIF»
 487                 «ENDFOR»
 488             }
 489         '''
 490     }
 491
 492     def private static writeAugments(Set<AugmentationSchemaNode> augments) {
 493         '''
 494             «FOR augment : augments»
 495                 «IF augment !== null»
 496                 «writeAugment(augment)»
 497                 «ENDIF»
 498             «ENDFOR»
 499         '''
 500     }
 501
 502     def private static writeDataSchemaNodes(Collection<DataSchemaNode> dataSchemaNodes) {
 503         '''
 504             «FOR schemaNode : dataSchemaNodes»
 505                 «writeDataSchemaNode(schemaNode)»
 506             «ENDFOR»
 507         '''
 508     }
 509
 510     def private static CharSequence writeGroupingDefs(Set<GroupingDefinition> groupingDefs) {
 511         '''
 512             «FOR groupingDef : groupingDefs»
 513                 «IF groupingDef !== null»
 514                 «writeGroupingDef(groupingDef)»
 515                 «ENDIF»
 516             «ENDFOR»
 517         '''
 518     }
 519
 520     def private static writeAugment(AugmentationSchemaNode augment) {
 521         '''
 522             augment «YangTextTemplate.formatToAugmentPath(augment.targetPath.pathFromRoot)» {
 523                 «IF augment.whenCondition !== null && !augment.whenCondition.toString.nullOrEmpty»
 524                 when "«augment.whenCondition.toString»";
 525                 «ENDIF»
 526                 «IF augment.description.present»
 527                 description
 528                     "«augment.description.get»";
 529                 «ENDIF»
 530                 «IF augment.reference.present»
 531                 reference
 532                     "«augment.reference.get»";
 533                 «ENDIF»
 534                 «IF augment.status !== null»
 535                 status «augment.status»;
 536                 «ENDIF»
 537                 «IF !augment.childNodes.nullOrEmpty»
 538                 «writeDataSchemaNodes(augment.childNodes)»
 539                 «ENDIF»
 540                 «IF !augment.uses.nullOrEmpty»
 541                 «writeUsesNodes(augment.uses)»
 542                 «ENDIF»
 543             }
 544         '''
 545     }
 546
 547     def private static writeGroupingDef(GroupingDefinition groupingDef) {
 548         var boolean isStatusDeprecated = groupingDef.status == Status::DEPRECATED
 549         '''
 550             grouping «groupingDef.QName.localName» {
 551                 «IF !groupingDef.groupings.nullOrEmpty»
 552                     «writeGroupingDefs(groupingDef.groupings)»
 553                 «ENDIF»
 554                 «IF !groupingDef.childNodes.nullOrEmpty»
 555                     «writeDataSchemaNodes(groupingDef.childNodes)»
 556                 «ENDIF»
 557                 «IF isStatusDeprecated»
 558                     status «groupingDef.status»;
 559                 «ENDIF»
 560                 «IF !groupingDef.unknownSchemaNodes.nullOrEmpty»
 561                     «writeUnknownSchemaNodes(groupingDef.unknownSchemaNodes)»
 562                 «ENDIF»
 563             }
 564         '''
 565     }
 566
 567     def private static writeContSchemaNode(ContainerSchemaNode contSchemaNode) {
 568         var boolean isStatusDeprecated = contSchemaNode.status == Status::DEPRECATED
 569         '''
 570             container «contSchemaNode.getQName.localName» {
 571                 «IF !contSchemaNode.childNodes.nullOrEmpty»
 572                 «writeDataSchemaNodes(contSchemaNode.childNodes)»
 573                 «ENDIF»
 574                 «IF !contSchemaNode.availableAugmentations.nullOrEmpty»
 575                 «writeAugments(contSchemaNode.availableAugmentations)»
 576                 «ENDIF»
 577                 «IF !contSchemaNode.groupings.nullOrEmpty»
 578                 «writeGroupingDefs(contSchemaNode.groupings)»
 579                 «ENDIF»
 580                 «IF !contSchemaNode.uses.nullOrEmpty»
 581                 «writeUsesNodes(contSchemaNode.uses)»
 582                 «ENDIF»
 583                 «IF isStatusDeprecated»
 584                 status «contSchemaNode.status»;
 585                 «ENDIF»
 586                 «IF !contSchemaNode.unknownSchemaNodes.nullOrEmpty»
 587                 «writeUnknownSchemaNodes(contSchemaNode.unknownSchemaNodes)»
 588                 «ENDIF»
 589             }
 590         '''
 591     }
 592
 593     def private static writeAnyXmlSchemaNode(AnyXmlSchemaNode anyXmlSchemaNode) {
 594         var boolean isStatusDeprecated = anyXmlSchemaNode.status == Status::DEPRECATED
 595         '''
 596             anyxml «anyXmlSchemaNode.getQName.localName»«IF !isStatusDeprecated»;«ELSE» {
 597                 status «anyXmlSchemaNode.status»;
 598             }
 599             «ENDIF»
 600         '''
 601     }
 602
 603     def private static writeLeafSchemaNode(LeafSchemaNode leafSchemaNode) {
 604         var boolean isStatusDeprecated = leafSchemaNode.status == Status::DEPRECATED
 605         '''
 606             leaf «leafSchemaNode.getQName.localName» {
 607                 type «leafSchemaNode.type.getQName.localName»;
 608                 «IF isStatusDeprecated»
 609                     status «leafSchemaNode.status»;
 610                 «ENDIF»
 611             }
 612         '''
 613     }
 614
 615     def private static writeLeafListSchemaNode(LeafListSchemaNode leafListSchemaNode) {
 616         var boolean isStatusDeprecated = leafListSchemaNode.status == Status::DEPRECATED
 617         '''
 618             leaf-list «leafListSchemaNode.getQName.localName» {
 619                 type «leafListSchemaNode.type.getQName.localName»;
 620                 «IF isStatusDeprecated»
 621                     status «leafListSchemaNode.status»;
 622                 «ENDIF»
 623             }
 624         '''
 625     }
 626
 627     def private static writeCaseSchemaNode(CaseSchemaNode choiceCaseNode) {
 628         var boolean isStatusDeprecated = choiceCaseNode.status == Status::DEPRECATED
 629         '''
 630             case «choiceCaseNode.getQName.localName» {
 631                 «FOR childNode : choiceCaseNode.childNodes»
 632                     «writeDataSchemaNode(childNode)»
 633                 «ENDFOR»
 634                 «IF isStatusDeprecated»
 635                     status «choiceCaseNode.status»;
 636                 «ENDIF»
 637             }
 638         '''
 639     }
 640
 641     def private static writeChoiceNode(ChoiceSchemaNode choiceNode) {
 642         var boolean isStatusDeprecated = choiceNode.status == Status::DEPRECATED
 643         '''
 644             choice «choiceNode.getQName.localName» {
 645                 «FOR child : choiceNode.cases.values»
 646                     «writeDataSchemaNode(child)»
 647                 «ENDFOR»
 648                 «IF isStatusDeprecated»
 649                     status «choiceNode.status»;
 650                 «ENDIF»
 651             }
 652         '''
 653     }
 654
 655     def private static writeListSchemaNode(ListSchemaNode listSchemaNode) {
 656         var boolean isStatusDeprecated = listSchemaNode.status == Status::DEPRECATED
 657
 658         '''
 659             list «listSchemaNode.getQName.localName» {
 660                 «IF !listSchemaNode.keyDefinition.empty»
 661                     key «FOR listKey : listSchemaNode.keyDefinition SEPARATOR " "»"«listKey.localName»"«ENDFOR»;
 662                 «ENDIF»
 663                 «IF !listSchemaNode.childNodes.nullOrEmpty»
 664                     «writeDataSchemaNodes(listSchemaNode.childNodes)»
 665                 «ENDIF»
 666                 «IF !listSchemaNode.availableAugmentations.nullOrEmpty»
 667                     «writeAugments(listSchemaNode.availableAugmentations)»
 668                 «ENDIF»
 669                 «IF !listSchemaNode.groupings.nullOrEmpty»
 670                     «writeGroupingDefs(listSchemaNode.groupings)»
 671                 «ENDIF»
 672                 «IF !listSchemaNode.uses.nullOrEmpty»
 673                     «writeUsesNodes(listSchemaNode.uses)»
 674                 «ENDIF»
 675                 «IF isStatusDeprecated»
 676                     status «listSchemaNode.status»;
 677                 «ENDIF»
 678                 «IF !listSchemaNode.unknownSchemaNodes.nullOrEmpty»
 679                     «writeUnknownSchemaNodes(listSchemaNode.unknownSchemaNodes)»
 680                 «ENDIF»
 681             }
 682         '''
 683     }
 684
 685     def private static CharSequence writeDataSchemaNode(DataSchemaNode child) {
 686         '''
 687             «IF child instanceof ContainerSchemaNode»
 688                 «writeContSchemaNode(child)»
 689             «ENDIF»
 690             «IF child instanceof AnyXmlSchemaNode»
 691                 «writeAnyXmlSchemaNode(child)»
 692             «ENDIF»
 693             «IF child instanceof LeafSchemaNode»
 694                 «writeLeafSchemaNode(child)»
 695             «ENDIF»
 696             «IF child instanceof LeafListSchemaNode»
 697                 «writeLeafListSchemaNode(child)»
 698             «ENDIF»
 699             «IF child instanceof CaseSchemaNode»
 700                 «writeCaseSchemaNode(child)»
 701             «ENDIF»
 702             «IF child instanceof ChoiceSchemaNode»
 703                 «writeChoiceNode(child)»
 704             «ENDIF»
 705             «IF child instanceof ListSchemaNode»
 706                 «writeListSchemaNode(child)»
 707             «ENDIF»
 708         '''
 709     }
 710 }