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