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