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                 «IF deviation.deviate != null && !deviation.deviate.name.nullOrEmpty»
 492                     deviation «deviation.deviate.name»;
 493                 «ENDIF»
 494             }
 495         '''
 496     }
 497
 498     def private static writeAugments(Set<AugmentationSchema> augments) {
 499         '''
 500             «FOR augment : augments»
 501                 «IF augment != null»
 502                 «writeAugment(augment)»
 503                 «ENDIF»
 504             «ENDFOR»
 505         '''
 506     }
 507
 508     def private static writeDataSchemaNodes(Collection<DataSchemaNode> dataSchemaNodes) {
 509         '''
 510             «FOR schemaNode : dataSchemaNodes»
 511                 «writeDataSchemaNode(schemaNode)»
 512             «ENDFOR»
 513         '''
 514     }
 515
 516     def private static CharSequence writeGroupingDefs(Set<GroupingDefinition> groupingDefs) {
 517         '''
 518             «FOR groupingDef : groupingDefs»
 519                 «IF groupingDef != null»
 520                 «writeGroupingDef(groupingDef)»
 521                 «ENDIF»
 522             «ENDFOR»
 523         '''
 524     }
 525
 526     def private static writeAugment(AugmentationSchema augment) {
 527         '''
 528             augment «YangTextTemplate.formatToAugmentPath(augment.targetPath.pathFromRoot)» {
 529                 «IF augment.whenCondition != null && !augment.whenCondition.toString.nullOrEmpty»
 530                 when "«augment.whenCondition.toString»";
 531                 «ENDIF»
 532                 «IF !augment.description.nullOrEmpty»
 533                 description
 534                     "«augment.description»";
 535                 «ENDIF»
 536                 «IF !augment.reference.nullOrEmpty»
 537                 reference
 538                     "«augment.reference»";
 539                 «ENDIF»
 540                 «IF augment.status != null»
 541                 status «augment.status»;
 542                 «ENDIF»
 543                 «IF !augment.childNodes.nullOrEmpty»
 544                 «writeDataSchemaNodes(augment.childNodes)»
 545                 «ENDIF»
 546                 «IF !augment.uses.nullOrEmpty»
 547                 «writeUsesNodes(augment.uses)»
 548                 «ENDIF»
 549             }
 550         '''
 551     }
 552
 553     def private static writeGroupingDef(GroupingDefinition groupingDef) {
 554         var boolean isStatusDeprecated = groupingDef.status == Status::DEPRECATED
 555         '''
 556             grouping «groupingDef.QName.localName» {
 557                 «IF !groupingDef.groupings.nullOrEmpty»
 558                     «writeGroupingDefs(groupingDef.groupings)»
 559                 «ENDIF»
 560                 «IF !groupingDef.childNodes.nullOrEmpty»
 561                     «writeDataSchemaNodes(groupingDef.childNodes)»
 562                 «ENDIF»
 563                 «IF isStatusDeprecated»
 564                     status «groupingDef.status»;
 565                 «ENDIF»
 566                 «IF !groupingDef.unknownSchemaNodes.nullOrEmpty»
 567                     «writeUnknownSchemaNodes(groupingDef.unknownSchemaNodes)»
 568                 «ENDIF»
 569             }
 570         '''
 571     }
 572
 573     def private static writeContSchemaNode(ContainerSchemaNode contSchemaNode) {
 574         var boolean isStatusDeprecated = contSchemaNode.status == Status::DEPRECATED
 575         '''
 576             container «contSchemaNode.getQName.localName» {
 577                 «IF !contSchemaNode.childNodes.nullOrEmpty»
 578                 «writeDataSchemaNodes(contSchemaNode.childNodes)»
 579                 «ENDIF»
 580                 «IF !contSchemaNode.availableAugmentations.nullOrEmpty»
 581                 «writeAugments(contSchemaNode.availableAugmentations)»
 582                 «ENDIF»
 583                 «IF !contSchemaNode.groupings.nullOrEmpty»
 584                 «writeGroupingDefs(contSchemaNode.groupings)»
 585                 «ENDIF»
 586                 «IF !contSchemaNode.uses.nullOrEmpty»
 587                 «writeUsesNodes(contSchemaNode.uses)»
 588                 «ENDIF»
 589                 «IF isStatusDeprecated»
 590                 status «contSchemaNode.status»;
 591                 «ENDIF»
 592                 «IF !contSchemaNode.unknownSchemaNodes.nullOrEmpty»
 593                 «writeUnknownSchemaNodes(contSchemaNode.unknownSchemaNodes)»
 594                 «ENDIF»
 595             }
 596         '''
 597     }
 598
 599     def private static writeAnyXmlSchemaNode(AnyXmlSchemaNode anyXmlSchemaNode) {
 600         var boolean isStatusDeprecated = anyXmlSchemaNode.status == Status::DEPRECATED
 601         '''
 602             anyxml «anyXmlSchemaNode.getQName.localName»«IF !isStatusDeprecated»;«ELSE» {
 603                 status «anyXmlSchemaNode.status»;
 604             }
 605             «ENDIF»
 606         '''
 607     }
 608
 609     def private static writeLeafSchemaNode(LeafSchemaNode leafSchemaNode) {
 610         var boolean isStatusDeprecated = leafSchemaNode.status == Status::DEPRECATED
 611         '''
 612             leaf «leafSchemaNode.getQName.localName» {
 613                 type «leafSchemaNode.type.getQName.localName»;
 614                 «IF isStatusDeprecated»
 615                     status «leafSchemaNode.status»;
 616                 «ENDIF»
 617             }
 618         '''
 619     }
 620
 621     def private static writeLeafListSchemaNode(LeafListSchemaNode leafListSchemaNode) {
 622         var boolean isStatusDeprecated = leafListSchemaNode.status == Status::DEPRECATED
 623         '''
 624             leaf-list «leafListSchemaNode.getQName.localName» {
 625                 type «leafListSchemaNode.type.getQName.localName»;
 626                 «IF isStatusDeprecated»
 627                     status «leafListSchemaNode.status»;
 628                 «ENDIF»
 629             }
 630         '''
 631     }
 632
 633     def private static writeChoiceCaseNode(ChoiceCaseNode choiceCaseNode) {
 634         var boolean isStatusDeprecated = choiceCaseNode.status == Status::DEPRECATED
 635         '''
 636             case «choiceCaseNode.getQName.localName» {
 637                 «FOR childNode : choiceCaseNode.childNodes»
 638                     «writeDataSchemaNode(childNode)»
 639                 «ENDFOR»
 640                 «IF isStatusDeprecated»
 641                     status «choiceCaseNode.status»;
 642                 «ENDIF»
 643             }
 644         '''
 645     }
 646
 647     def private static writeChoiceNode(ChoiceSchemaNode choiceNode) {
 648         var boolean isStatusDeprecated = choiceNode.status == Status::DEPRECATED
 649         '''
 650             choice «choiceNode.getQName.localName» {
 651                 «FOR child : choiceNode.cases»
 652                     «writeDataSchemaNode(child)»
 653                 «ENDFOR»
 654                 «IF isStatusDeprecated»
 655                     status «choiceNode.status»;
 656                 «ENDIF»
 657             }
 658         '''
 659     }
 660
 661     def private static writeListSchemaNode(ListSchemaNode listSchemaNode) {
 662         var boolean isStatusDeprecated = listSchemaNode.status == Status::DEPRECATED
 663
 664         '''
 665             list «listSchemaNode.getQName.localName» {
 666                 key «FOR listKey : listSchemaNode.keyDefinition SEPARATOR " "»"«listKey.localName»"
 667                 «ENDFOR»
 668                 «IF !listSchemaNode.childNodes.nullOrEmpty»
 669                     «writeDataSchemaNodes(listSchemaNode.childNodes)»
 670                 «ENDIF»
 671                 «IF !listSchemaNode.availableAugmentations.nullOrEmpty»
 672                     «writeAugments(listSchemaNode.availableAugmentations)»
 673                 «ENDIF»
 674                 «IF !listSchemaNode.groupings.nullOrEmpty»
 675                     «writeGroupingDefs(listSchemaNode.groupings)»
 676                 «ENDIF»
 677                 «IF !listSchemaNode.uses.nullOrEmpty»
 678                     «writeUsesNodes(listSchemaNode.uses)»
 679                 «ENDIF»
 680                 «IF isStatusDeprecated»
 681                     status «listSchemaNode.status»;
 682                 «ENDIF»
 683                 «IF !listSchemaNode.unknownSchemaNodes.nullOrEmpty»
 684                     «writeUnknownSchemaNodes(listSchemaNode.unknownSchemaNodes)»
 685                 «ENDIF»
 686             }
 687         '''
 688     }
 689
 690     def private static CharSequence writeDataSchemaNode(DataSchemaNode child) {
 691         '''
 692             «IF child instanceof ContainerSchemaNode»
 693                 «writeContSchemaNode(child)»
 694             «ENDIF»
 695             «IF child instanceof AnyXmlSchemaNode»
 696                 «writeAnyXmlSchemaNode(child)»
 697             «ENDIF»
 698             «IF child instanceof LeafSchemaNode»
 699                 «writeLeafSchemaNode(child)»
 700             «ENDIF»
 701             «IF child instanceof LeafListSchemaNode»
 702                 «writeLeafListSchemaNode(child)»
 703             «ENDIF»
 704             «IF child instanceof ChoiceCaseNode»
 705                 «writeChoiceCaseNode(child)»
 706             «ENDIF»
 707             «IF child instanceof ChoiceSchemaNode»
 708                 «writeChoiceNode(child)»
 709             «ENDIF»
 710             «IF child instanceof ListSchemaNode»
 711                 «writeListSchemaNode(child)»
 712             «ENDIF»
 713         '''
 714     }
 715 }