binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/YangTemplate.xtend

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