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