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