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         '''
 103             enum «pair.name» {
 104                 value «pair.value»;
 105             }
 106         '''
 107     }
 108
 109     def private static String writeModuleImports(Set<ModuleImport> moduleImports) {
 110         if (moduleImports.nullOrEmpty)
 111             return ''
 112
 113         '''
 114             «FOR moduleImport : moduleImports SEPARATOR "\n"»
 115                 «IF moduleImport != null && !moduleImport.moduleName.nullOrEmpty»
 116                 import «moduleImport.moduleName» { prefix "«moduleImport.prefix»"; }
 117                 «ENDIF»
 118             «ENDFOR»
 119         '''
 120     }
 121
 122     def private static writeRevision(Date moduleRevision, String moduleDescription) {
 123         val revisionIndent = 12
 124
 125         '''
 126             revision «SimpleDateFormatUtil.getRevisionFormat.format(moduleRevision)» {
 127                 description "«YangTextTemplate.formatToParagraph(moduleDescription, revisionIndent)»";
 128             }
 129         '''
 130     }
 131
 132     def static String generateYangSnipet(Module module) {
 133
 134         '''
 135             module «module.name» {
 136                 yang-version «module.yangVersion»;
 137                 namespace "«module.QNameModule.namespace.toString»";
 138                 prefix "«module.prefix»";
 139
 140                 «IF !module.imports.nullOrEmpty»
 141                 «writeModuleImports(module.imports)»
 142                 «ENDIF»
 143                 «IF module.revision != null»
 144                 «writeRevision(module.revision, module.description)»
 145                 «ENDIF»
 146                 «IF !module.childNodes.nullOrEmpty»
 147
 148                 «writeDataSchemaNodes(module.childNodes)»
 149                 «ENDIF»
 150                 «IF !module.groupings.nullOrEmpty»
 151
 152                 «writeGroupingDefs(module.groupings)»
 153                 «ENDIF»
 154                 «IF !module.augmentations.nullOrEmpty»
 155
 156                 «writeAugments(module.augmentations)»
 157                 «ENDIF»
 158                 «IF !module.deviations.nullOrEmpty»
 159
 160                 «writeDeviations(module.deviations)»
 161                 «ENDIF»
 162                 «IF !module.extensionSchemaNodes.nullOrEmpty»
 163
 164                 «writeExtensions(module.extensionSchemaNodes)»
 165                 «ENDIF»
 166                 «IF !module.features.nullOrEmpty»
 167
 168                 «writeFeatures(module.features)»
 169                 «ENDIF»
 170                 «IF !module.identities.nullOrEmpty»
 171
 172                 «writeIdentities(module.identities)»
 173                 «ENDIF»
 174                 «IF !module.notifications.nullOrEmpty»
 175
 176                 «writeNotifications(module.notifications)»
 177                 «ENDIF»
 178                 «IF !module.rpcs.nullOrEmpty»
 179
 180                 «writeRPCs(module.rpcs)»
 181                 «ENDIF»
 182                 «IF !module.unknownSchemaNodes.nullOrEmpty»
 183
 184                 «writeUnknownSchemaNodes(module.unknownSchemaNodes)»
 185                 «ENDIF»
 186                 «IF !module.uses.nullOrEmpty»
 187
 188                 «writeUsesNodes(module.uses)»
 189                 «ENDIF»
 190             }
 191         '''
 192     }
 193
 194     def private static writeRPCs(Set<RpcDefinition> rpcDefs) {
 195         '''
 196             «FOR rpc : rpcDefs»
 197                 «IF rpc != null»
 198                 «writeRPC(rpc)»
 199                 «ENDIF»
 200             «ENDFOR»
 201         '''
 202     }
 203
 204     def private static writeRPC(RpcDefinition rpc) {
 205         var boolean isStatusDeprecated = rpc.status == Status::DEPRECATED
 206         '''
 207             rpc «rpc.QName.localName» {
 208                 «IF !rpc.description.nullOrEmpty»
 209                     "«rpc.description»";
 210                 «ENDIF»
 211                 «IF !rpc.groupings.nullOrEmpty»
 212                     «writeGroupingDefs(rpc.groupings)»
 213                 «ENDIF»
 214                 «IF rpc.input != null»
 215                     «writeRpcInput(rpc.input)»
 216                 «ENDIF»
 217                 «IF rpc.output != null»
 218                     «writeRpcOutput(rpc.output)»
 219                 «ENDIF»
 220                 «IF !rpc.reference.nullOrEmpty»
 221                 reference
 222                     "«rpc.reference»";
 223                 «ENDIF»
 224                 «IF isStatusDeprecated»
 225                 status «rpc.status»;
 226                 «ENDIF»
 227             }
 228         '''
 229     }
 230
 231     def private static writeRpcInput(ContainerSchemaNode input) {
 232         if(input == null)
 233             return ''
 234
 235         '''
 236             input {
 237                 «IF !input.childNodes.nullOrEmpty»
 238                 «writeDataSchemaNodes(input.childNodes)»
 239                 «ENDIF»
 240             }
 241
 242         '''
 243     }
 244
 245     def private static writeRpcOutput(ContainerSchemaNode output) {
 246         if(output == null)
 247             return ''
 248
 249         '''
 250             output {
 251                 «IF !output.childNodes.nullOrEmpty»
 252                 «writeDataSchemaNodes(output.childNodes)»
 253                 «ENDIF»
 254             }
 255         '''
 256     }
 257
 258     def private static writeNotifications(Set<NotificationDefinition> notifications) {
 259         '''
 260             «FOR notification : notifications»
 261                 «IF notification != null»
 262                 «writeNotification(notification)»
 263                 «ENDIF»
 264             «ENDFOR»
 265         '''
 266     }
 267
 268     def private static writeNotification(NotificationDefinition notification) {
 269         var boolean isStatusDeprecated = notification.status == Status::DEPRECATED
 270         '''
 271             notification «notification.QName.localName» {
 272                 «IF !notification.description.nullOrEmpty»
 273                 description
 274                     "«notification.description»";
 275                 «ENDIF»
 276                 «IF !notification.childNodes.nullOrEmpty»
 277                     «writeDataSchemaNodes(notification.childNodes)»
 278                 «ENDIF»
 279                 «IF !notification.availableAugmentations.nullOrEmpty»
 280                     «writeAugments(notification.availableAugmentations)»
 281                 «ENDIF»
 282                 «IF !notification.groupings.nullOrEmpty»
 283                     «writeGroupingDefs(notification.groupings)»
 284                 «ENDIF»
 285                 «IF !notification.uses.nullOrEmpty»
 286                     «writeUsesNodes(notification.uses)»
 287                 «ENDIF»
 288                 «IF !notification.reference.nullOrEmpty»
 289                 reference
 290                     "«notification.reference»";
 291                 «ENDIF»
 292                 «IF isStatusDeprecated»
 293                 status «notification.status»;
 294                 «ENDIF»
 295             }
 296         '''
 297     }
 298
 299     def private static writeUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
 300         if (unknownSchemaNodes.nullOrEmpty)
 301             return ''
 302
 303         '''
 304             «FOR unknownSchemaNode : unknownSchemaNodes»
 305                 «writeUnknownSchemaNode(unknownSchemaNode)»
 306             «ENDFOR»
 307         '''
 308     }
 309
 310     def private static writeUnknownSchemaNode(UnknownSchemaNode unknownSchemaNode) {
 311         return ''
 312     }
 313
 314     def private static writeUsesNodes(Set<UsesNode> usesNodes) {
 315         if (usesNodes == null) {
 316             return ''
 317         }
 318
 319         '''
 320             «FOR usesNode : usesNodes»
 321                 «IF usesNode != null»
 322                 «writeUsesNode(usesNode)»
 323                 «ENDIF»
 324             «ENDFOR»
 325         '''
 326     }
 327
 328     def private static writeUsesNode(UsesNode usesNode) {
 329         val hasRefines = !usesNode.refines.empty
 330
 331         '''
 332             uses «usesNode.groupingPath.pathFromRoot.head.localName»«IF !hasRefines»;«ELSE» {«ENDIF»
 333             «IF hasRefines»
 334                 «writeRefines(usesNode.refines)»
 335             }
 336             «ENDIF»
 337         '''
 338     }
 339
 340     def private static writeRefines(Map<SchemaPath, SchemaNode> refines) {
 341         '''
 342             «FOR path : refines.keySet»
 343             «val schemaNode = refines.get(path)»
 344             «writeRefine(path, schemaNode)»
 345             «ENDFOR»
 346         '''
 347     }
 348
 349     def private static writeRefine(SchemaPath path, SchemaNode schemaNode) {
 350         '''
 351             refine «path.pathFromRoot.last» {
 352                 «IF schemaNode instanceof DataSchemaNode»
 353                 «writeDataSchemaNode(schemaNode)»
 354                 «ENDIF»
 355             }
 356         '''
 357     }
 358
 359     def private static writeTypeDefinition(TypeDefinition<?> typeDefinition) {
 360         var boolean isStatusDeprecated = typeDefinition.status == Status::DEPRECATED
 361         '''
 362             type «typeDefinition.QName.localName»«IF !isStatusDeprecated»;«ELSE» {
 363                 status «typeDefinition.status»;
 364             }
 365             «ENDIF»
 366         '''
 367     }
 368
 369     def private static writeIdentities(Set<IdentitySchemaNode> identities) {
 370         if (identities.nullOrEmpty)
 371             return ''
 372         '''
 373             «FOR identity : identities»
 374                 «writeIdentity(identity)»
 375             «ENDFOR»
 376         '''
 377     }
 378
 379     def private static writeIdentity(IdentitySchemaNode identity) {
 380         if (identity == null)
 381             return ''
 382         '''
 383             identity «identity.QName.localName» {
 384                 «IF identity.baseIdentity != null»
 385                 base "(«writeIdentityNs(identity.baseIdentity)»)«identity.baseIdentity»";
 386                 «ENDIF»
 387                 «IF !identity.description.nullOrEmpty»
 388                 description
 389                     "«identity.description»";
 390                 «ENDIF»
 391                 «IF !identity.reference.nullOrEmpty»
 392                 reference
 393                     "«identity.reference»";
 394                 «ENDIF»
 395                 «IF identity.status != null»
 396                 status «identity.status»;
 397                 «ENDIF»
 398             }
 399         '''
 400     }
 401
 402     def private static writeIdentityNs(IdentitySchemaNode identity) {
 403         if(module == null)
 404             return ''
 405
 406         val identityNs = identity.QName.namespace
 407
 408         if(!module.namespace.equals(identityNs))
 409             return identityNs + ":"
 410         return ''
 411     }
 412
 413     def private static writeFeatures(Set<FeatureDefinition> features) {
 414         '''
 415             «FOR feature : features»
 416                 «IF feature != null»
 417                 «writeFeature(feature)»
 418                 «ENDIF»
 419             «ENDFOR»
 420         '''
 421     }
 422
 423     def private static writeFeature(FeatureDefinition featureDef) {
 424         '''
 425             feature «featureDef.QName.localName» {
 426                 «IF !featureDef.description.nullOrEmpty»
 427                 description
 428                     "«featureDef.description»";
 429                 «ENDIF»
 430                 «IF !featureDef.reference.nullOrEmpty»
 431                 reference
 432                     "«featureDef.reference»";
 433                 «ENDIF»
 434                 «IF featureDef.status != null»
 435                 status «featureDef.status»;
 436                 «ENDIF»
 437             }
 438         '''
 439     }
 440
 441     def private static writeExtensions(List<ExtensionDefinition> extensions) {
 442         '''
 443             «FOR anExtension : extensions»
 444                 «IF anExtension != null»
 445                 «writeExtension(anExtension)»
 446                 «ENDIF»
 447             «ENDFOR»
 448         '''
 449     }
 450
 451     def private static writeExtension(ExtensionDefinition extensionDef) {
 452         '''
 453             extension «extensionDef.QName.localName» {
 454                 «IF !extensionDef.description.nullOrEmpty»
 455                 description
 456                     "«extensionDef.description»";
 457                 «ENDIF»
 458                 «IF !extensionDef.argument.nullOrEmpty»
 459                 argument "«extensionDef.argument»";
 460                 «ENDIF»
 461                 «IF !extensionDef.reference.nullOrEmpty»
 462                 reference
 463                     "«extensionDef.reference»";
 464                 «ENDIF»
 465                 «IF extensionDef.status != null»
 466                 status «extensionDef.status»;
 467                 «ENDIF»
 468             }
 469         '''
 470     }
 471
 472     def private static writeDeviations(Set<Deviation> deviations) {
 473         '''
 474             «FOR deviation : deviations»
 475                 «IF deviation != null»
 476                 «writeDeviation(deviation)»
 477                 «ENDIF»
 478             «ENDFOR»
 479         '''
 480     }
 481
 482     def private static writeDeviation(Deviation deviation) {
 483         '''
 484             deviation «deviation.targetPath» {
 485                 «IF !deviation.reference.nullOrEmpty»
 486                     reference
 487                         "«deviation.reference»";
 488                 «ENDIF»
 489                 «FOR dev : deviation.deviates»
 490                     «IF dev != null && dev.deviateType != null»
 491                         deviation «dev.deviateType.name»;
 492                     «ENDIF»
 493                 «ENDFOR»
 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 }