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 com.google.common.base.CharMatcher
  11 import java.util.Collection
  12 import java.util.Date
  13 import java.util.List
  14 import java.util.Map
  15 import java.util.Set
  16 import java.util.StringTokenizer
  17 import org.opendaylight.yangtools.yang.common.QName
  18 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil
  19 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode
  20 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema
  21 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode
  22 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode
  23 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode
  24 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
  25 import org.opendaylight.yangtools.yang.model.api.Deviation
  26 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition
  27 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition
  28 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition
  29 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode
  30 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode
  31 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode
  32 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode
  33 import org.opendaylight.yangtools.yang.model.api.Module
  34 import org.opendaylight.yangtools.yang.model.api.ModuleImport
  35 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition
  36 import org.opendaylight.yangtools.yang.model.api.RpcDefinition
  37 import org.opendaylight.yangtools.yang.model.api.SchemaNode
  38 import org.opendaylight.yangtools.yang.model.api.SchemaPath
  39 import org.opendaylight.yangtools.yang.model.api.Status
  40 import org.opendaylight.yangtools.yang.model.api.TypeDefinition
  41 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode
  42 import org.opendaylight.yangtools.yang.model.api.UsesNode
  43 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition
  44 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair
  45
  46 class YangTemplate {
  47
  48     // FIXME: this is not thread-safe and seems to be unused!
  49     private static var Module module = null
  50
  51     private static val CharMatcher NEWLINE_OR_TAB = CharMatcher.anyOf("\n\t")
  52
  53     def static String generateYangSnipet(SchemaNode schemaNode) {
  54         if (schemaNode == null)
  55             return ''
  56
  57         '''
  58             «IF schemaNode instanceof DataSchemaNode»
  59             «writeDataSchemaNode(schemaNode)»
  60             «ENDIF»
  61             «IF schemaNode instanceof EnumTypeDefinition.EnumPair»
  62             «writeEnumPair(schemaNode)»
  63             «ENDIF»
  64             «IF schemaNode instanceof ExtensionDefinition»
  65             «writeExtension(schemaNode)»
  66             «ENDIF»
  67             «IF schemaNode instanceof FeatureDefinition»
  68             «writeFeature(schemaNode)»
  69             «ENDIF»
  70             «IF schemaNode instanceof GroupingDefinition»
  71             «writeGroupingDef(schemaNode)»
  72             «ENDIF»
  73             «IF schemaNode instanceof IdentitySchemaNode»
  74             «writeIdentity(schemaNode)»
  75             «ENDIF»
  76             «IF schemaNode instanceof NotificationDefinition»
  77             «writeNotification(schemaNode)»
  78             «ENDIF»
  79             «IF schemaNode instanceof RpcDefinition»
  80             «writeRPC(schemaNode)»
  81             «ENDIF»
  82             «IF schemaNode instanceof TypeDefinition<?>»
  83             «writeTypeDefinition(schemaNode)»
  84             «ENDIF»
  85             «IF schemaNode instanceof UnknownSchemaNode»
  86             «writeUnknownSchemaNode(schemaNode)»
  87             «ENDIF»
  88         '''
  89     }
  90
  91     def static String generateYangSnipet(Set<? extends SchemaNode> nodes) {
  92         if (nodes.nullOrEmpty)
  93             return ''
  94
  95         '''
  96             «FOR node : nodes»
  97                 «IF node instanceof NotificationDefinition»
  98                 «writeNotification(node)»
  99                 «ELSEIF node instanceof RpcDefinition»
 100                 «writeRPC(node as RpcDefinition)»
 101                 «ENDIF»
 102             «ENDFOR»
 103         '''
 104     }
 105
 106     def static writeEnumPair(EnumPair pair) {
 107         var boolean hasEnumPairValue = pair.value != null
 108         '''
 109             enum «pair.name»«IF !hasEnumPairValue»;«ELSE»{
 110                 value «pair.value»;
 111             }
 112             «ENDIF»
 113         '''
 114     }
 115
 116     def static String writeModuleImports(Set<ModuleImport> moduleImports) {
 117         if (moduleImports.nullOrEmpty)
 118             return ''
 119
 120         '''
 121             «FOR moduleImport : moduleImports SEPARATOR "\n"»
 122                 «IF moduleImport != null && !moduleImport.moduleName.nullOrEmpty»
 123                 import «moduleImport.moduleName» { prefix "«moduleImport.prefix»"; }
 124                 «ENDIF»
 125             «ENDFOR»
 126         '''
 127     }
 128
 129     def static writeRevision(Date moduleRevision, String moduleDescription) {
 130         val revisionIndent = 12
 131
 132         '''
 133             revision «SimpleDateFormatUtil.getRevisionFormat.format(moduleRevision)» {
 134                 description "«formatToParagraph(moduleDescription, revisionIndent)»";
 135             }
 136         '''
 137     }
 138
 139     def static String generateYangSnipet(Module module) {
 140
 141         '''
 142             module «module.name» {
 143                 yang-version «module.yangVersion»;
 144                 namespace "«module.QNameModule.namespace.toString»";
 145                 prefix "«module.prefix»";
 146
 147                 «IF !module.imports.nullOrEmpty»
 148                 «writeModuleImports(module.imports)»
 149                 «ENDIF»
 150                 «IF module.revision != null»
 151                 «writeRevision(module.revision, module.description)»
 152                 «ENDIF»
 153                 «IF !module.childNodes.nullOrEmpty»
 154
 155                 «writeDataSchemaNodes(module.childNodes)»
 156                 «ENDIF»
 157                 «IF !module.groupings.nullOrEmpty»
 158
 159                 «writeGroupingDefs(module.groupings)»
 160                 «ENDIF»
 161                 «IF !module.augmentations.nullOrEmpty»
 162
 163                 «writeAugments(module.augmentations)»
 164                 «ENDIF»
 165                 «IF !module.deviations.nullOrEmpty»
 166
 167                 «writeDeviations(module.deviations)»
 168                 «ENDIF»
 169                 «IF !module.extensionSchemaNodes.nullOrEmpty»
 170
 171                 «writeExtensions(module.extensionSchemaNodes)»
 172                 «ENDIF»
 173                 «IF !module.features.nullOrEmpty»
 174
 175                 «writeFeatures(module.features)»
 176                 «ENDIF»
 177                 «IF !module.identities.nullOrEmpty»
 178
 179                 «writeIdentities(module.identities)»
 180                 «ENDIF»
 181                 «IF !module.notifications.nullOrEmpty»
 182
 183                 «writeNotifications(module.notifications)»
 184                 «ENDIF»
 185                 «IF !module.rpcs.nullOrEmpty»
 186
 187                 «writeRPCs(module.rpcs)»
 188                 «ENDIF»
 189                 «IF !module.unknownSchemaNodes.nullOrEmpty»
 190
 191                 «writeUnknownSchemaNodes(module.unknownSchemaNodes)»
 192                 «ENDIF»
 193                 «IF !module.uses.nullOrEmpty»
 194
 195                 «writeUsesNodes(module.uses)»
 196                 «ENDIF»
 197             }
 198         '''
 199     }
 200
 201     def static writeRPCs(Set<RpcDefinition> rpcDefs) {
 202         '''
 203             «FOR rpc : rpcDefs»
 204                 «IF rpc != null»
 205                 «writeRPC(rpc)»
 206                 «ENDIF»
 207             «ENDFOR»
 208         '''
 209     }
 210
 211     def static writeRPC(RpcDefinition rpc) {
 212         var boolean isStatusDeprecated = rpc.status == Status::DEPRECATED
 213         '''
 214             rpc «rpc.QName.localName» {
 215                 «IF !rpc.description.nullOrEmpty»
 216                     "«rpc.description»";
 217                 «ENDIF»
 218                 «IF !rpc.groupings.nullOrEmpty»
 219                     «writeGroupingDefs(rpc.groupings)»
 220                 «ENDIF»
 221                 «IF rpc.input != null»
 222                     «writeRpcInput(rpc.input)»
 223                 «ENDIF»
 224                 «IF rpc.output != null»
 225                     «writeRpcOutput(rpc.output)»
 226                 «ENDIF»
 227                 «IF !rpc.reference.nullOrEmpty»
 228                 reference
 229                     "«rpc.reference»";
 230                 «ENDIF»
 231                 «IF isStatusDeprecated»
 232                 status «rpc.status»;
 233                 «ENDIF»
 234             }
 235         '''
 236     }
 237
 238     def static writeRpcInput(ContainerSchemaNode input) {
 239         if(input == null)
 240             return ''
 241
 242         '''
 243             input {
 244                 «IF !input.childNodes.nullOrEmpty»
 245                 «writeDataSchemaNodes(input.childNodes)»
 246                 «ENDIF»
 247             }
 248
 249         '''
 250     }
 251
 252     def static writeRpcOutput(ContainerSchemaNode output) {
 253         if(output == null)
 254             return ''
 255
 256         '''
 257             output {
 258                 «IF !output.childNodes.nullOrEmpty»
 259                 «writeDataSchemaNodes(output.childNodes)»
 260                 «ENDIF»
 261             }
 262         '''
 263     }
 264
 265     def static writeNotifications(Set<NotificationDefinition> notifications) {
 266         '''
 267             «FOR notification : notifications»
 268                 «IF notification != null»
 269                 «writeNotification(notification)»
 270                 «ENDIF»
 271             «ENDFOR»
 272         '''
 273     }
 274
 275     def static writeNotification(NotificationDefinition notification) {
 276         var boolean isStatusDeprecated = notification.status == Status::DEPRECATED
 277         '''
 278             notification «notification.QName.localName» {
 279                 «IF !notification.description.nullOrEmpty»
 280                 description
 281                     "«notification.description»";
 282                 «ENDIF»
 283                 «IF !notification.childNodes.nullOrEmpty»
 284                     «writeDataSchemaNodes(notification.childNodes)»
 285                 «ENDIF»
 286                 «IF !notification.availableAugmentations.nullOrEmpty»
 287                     «writeAugments(notification.availableAugmentations)»
 288                 «ENDIF»
 289                 «IF !notification.groupings.nullOrEmpty»
 290                     «writeGroupingDefs(notification.groupings)»
 291                 «ENDIF»
 292                 «IF !notification.uses.nullOrEmpty»
 293                     «writeUsesNodes(notification.uses)»
 294                 «ENDIF»
 295                 «IF !notification.reference.nullOrEmpty»
 296                 reference
 297                     "«notification.reference»";
 298                 «ENDIF»
 299                 «IF isStatusDeprecated»
 300                 status «notification.status»;
 301                 «ENDIF»
 302             }
 303         '''
 304     }
 305
 306     def static writeUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
 307         if (unknownSchemaNodes.nullOrEmpty)
 308             return ''
 309
 310         '''
 311             «FOR unknownSchemaNode : unknownSchemaNodes»
 312                 «writeUnknownSchemaNode(unknownSchemaNode)»
 313             «ENDFOR»
 314         '''
 315     }
 316
 317     def static writeUnknownSchemaNode(UnknownSchemaNode unknownSchemaNode) {
 318         return ''
 319     }
 320
 321     def static writeUsesNodes(Set<UsesNode> usesNodes) {
 322         if (usesNodes == null) {
 323             return ''
 324         }
 325
 326         '''
 327             «FOR usesNode : usesNodes»
 328                 «IF usesNode != null»
 329                 «writeUsesNode(usesNode)»
 330                 «ENDIF»
 331             «ENDFOR»
 332         '''
 333     }
 334
 335     def static writeUsesNode(UsesNode usesNode) {
 336         val hasRefines = !usesNode.refines.empty
 337
 338         '''
 339             uses «usesNode.groupingPath.pathFromRoot.head.localName»«IF !hasRefines»;«ELSE» {«ENDIF»
 340             «IF hasRefines»
 341                 «writeRefines(usesNode.refines)»
 342             }
 343             «ENDIF»
 344         '''
 345     }
 346
 347     def static writeRefines(Map<SchemaPath, SchemaNode> refines) {
 348         '''
 349             «FOR path : refines.keySet»
 350             «val schemaNode = refines.get(path)»
 351             «writeRefine(path, schemaNode)»
 352             «ENDFOR»
 353         '''
 354     }
 355
 356     def static writeRefine(SchemaPath path, SchemaNode schemaNode) {
 357         '''
 358             refine «path.pathFromRoot.last» {
 359                 «IF schemaNode instanceof DataSchemaNode»
 360                 «writeDataSchemaNode(schemaNode)»
 361                 «ENDIF»
 362             }
 363         '''
 364     }
 365
 366     def static writeTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
 367         '''
 368             «FOR typeDefinition : typeDefinitions»
 369                 «IF typeDefinition != null»
 370                 «writeTypeDefinition(typeDefinition)»
 371                 «ENDIF»
 372             «ENDFOR»
 373         '''
 374     }
 375
 376     def static writeTypeDefinition(TypeDefinition<?> typeDefinition) {
 377         var boolean isStatusDeprecated = typeDefinition.status == Status::DEPRECATED
 378         '''
 379             type «typeDefinition.QName.localName»«IF !isStatusDeprecated»;«ELSE» {
 380                 status «typeDefinition.status»;
 381             }
 382             «ENDIF»
 383         '''
 384     }
 385
 386     def static writeIdentities(Set<IdentitySchemaNode> identities) {
 387         if (identities.nullOrEmpty)
 388             return ''
 389         '''
 390             «FOR identity : identities»
 391                 «writeIdentity(identity)»
 392             «ENDFOR»
 393         '''
 394     }
 395
 396     def static writeIdentity(IdentitySchemaNode identity) {
 397         if (identity == null)
 398             return ''
 399         '''
 400             identity «identity.QName.localName» {
 401                 «IF identity.baseIdentity != null»
 402                 base "(«writeIdentityNs(identity.baseIdentity)»)«identity.baseIdentity»";
 403                 «ENDIF»
 404                 «IF !identity.description.nullOrEmpty»
 405                 description
 406                     "«identity.description»";
 407                 «ENDIF»
 408                 «IF !identity.reference.nullOrEmpty»
 409                 reference
 410                     "«identity.reference»";
 411                 «ENDIF»
 412                 «IF identity.status != null»
 413                 status «identity.status»;
 414                 «ENDIF»
 415             }
 416         '''
 417     }
 418
 419     def static writeIdentityNs(IdentitySchemaNode identity) {
 420         if(module == null)
 421             return ''
 422
 423         val identityNs = identity.QName.namespace
 424
 425         if(!module.namespace.equals(identityNs))
 426             return identityNs + ":"
 427         return ''
 428     }
 429
 430     def static writeFeatures(Set<FeatureDefinition> features) {
 431         '''
 432             «FOR feature : features»
 433                 «IF feature != null»
 434                 «writeFeature(feature)»
 435                 «ENDIF»
 436             «ENDFOR»
 437         '''
 438     }
 439
 440     def static writeFeature(FeatureDefinition featureDef) {
 441         '''
 442             feature «featureDef.QName.localName» {
 443                 «IF !featureDef.description.nullOrEmpty»
 444                 description
 445                     "«featureDef.description»";
 446                 «ENDIF»
 447                 «IF !featureDef.reference.nullOrEmpty»
 448                 reference
 449                     "«featureDef.reference»";
 450                 «ENDIF»
 451                 «IF featureDef.status != null»
 452                 status «featureDef.status»;
 453                 «ENDIF»
 454             }
 455         '''
 456     }
 457
 458     def static writeExtensions(List<ExtensionDefinition> extensions) {
 459         '''
 460             «FOR anExtension : extensions»
 461                 «IF anExtension != null»
 462                 «writeExtension(anExtension)»
 463                 «ENDIF»
 464             «ENDFOR»
 465         '''
 466     }
 467
 468     def static writeExtension(ExtensionDefinition extensionDef) {
 469         '''
 470             extension «extensionDef.QName.localName» {
 471                 «IF !extensionDef.description.nullOrEmpty»
 472                 description
 473                     "«extensionDef.description»";
 474                 «ENDIF»
 475                 «IF !extensionDef.argument.nullOrEmpty»
 476                 argument "«extensionDef.argument»";
 477                 «ENDIF»
 478                 «IF !extensionDef.reference.nullOrEmpty»
 479                 reference
 480                     "«extensionDef.reference»";
 481                 «ENDIF»
 482                 «IF extensionDef.status != null»
 483                 status «extensionDef.status»;
 484                 «ENDIF»
 485             }
 486         '''
 487     }
 488
 489     def static writeDeviations(Set<Deviation> deviations) {
 490         '''
 491             «FOR deviation : deviations»
 492                 «IF deviation != null»
 493                 «writeDeviation(deviation)»
 494                 «ENDIF»
 495             «ENDFOR»
 496         '''
 497     }
 498
 499     def static writeDeviation(Deviation deviation) {
 500         '''
 501             deviation «deviation.targetPath» {
 502                 «IF !deviation.reference.nullOrEmpty»
 503                     reference
 504                         "«deviation.reference»";
 505                 «ENDIF»
 506                 «IF deviation.deviate != null && !deviation.deviate.name.nullOrEmpty»
 507                     deviation «deviation.deviate.name»;
 508                 «ENDIF»
 509             }
 510         '''
 511     }
 512
 513     def static writeAugments(Set<AugmentationSchema> augments) {
 514         '''
 515             «FOR augment : augments»
 516                 «IF augment != null»
 517                 «writeAugment(augment)»
 518                 «ENDIF»
 519             «ENDFOR»
 520         '''
 521     }
 522
 523     def static writeDataSchemaNodes(Collection<DataSchemaNode> dataSchemaNodes) {
 524         '''
 525             «FOR schemaNode : dataSchemaNodes»
 526                 «writeDataSchemaNode(schemaNode)»
 527             «ENDFOR»
 528         '''
 529     }
 530
 531     def static CharSequence writeGroupingDefs(Set<GroupingDefinition> groupingDefs) {
 532         '''
 533             «FOR groupingDef : groupingDefs»
 534                 «IF groupingDef != null»
 535                 «writeGroupingDef(groupingDef)»
 536                 «ENDIF»
 537             «ENDFOR»
 538         '''
 539     }
 540
 541     def static writeAugment(AugmentationSchema augment) {
 542         '''
 543             augment «formatToAugmentPath(augment.targetPath.pathFromRoot)» {
 544                 «IF augment.whenCondition != null && !augment.whenCondition.toString.nullOrEmpty»
 545                 when "«augment.whenCondition.toString»";
 546                 «ENDIF»
 547                 «IF !augment.description.nullOrEmpty»
 548                 description
 549                     "«augment.description»";
 550                 «ENDIF»
 551                 «IF !augment.reference.nullOrEmpty»
 552                 reference
 553                     "«augment.reference»";
 554                 «ENDIF»
 555                 «IF augment.status != null»
 556                 status «augment.status»;
 557                 «ENDIF»
 558                 «IF !augment.childNodes.nullOrEmpty»
 559                 «writeDataSchemaNodes(augment.childNodes)»
 560                 «ENDIF»
 561                 «IF !augment.uses.nullOrEmpty»
 562                 «writeUsesNodes(augment.uses)»
 563                 «ENDIF»
 564             }
 565         '''
 566     }
 567
 568     def static writeGroupingDef(GroupingDefinition groupingDef) {
 569         var boolean isStatusDeprecated = groupingDef.status == Status::DEPRECATED
 570         '''
 571             grouping «groupingDef.QName.localName» {
 572                 «IF !groupingDef.groupings.nullOrEmpty»
 573                     «writeGroupingDefs(groupingDef.groupings)»
 574                 «ENDIF»
 575                 «IF !groupingDef.childNodes.nullOrEmpty»
 576                     «writeDataSchemaNodes(groupingDef.childNodes)»
 577                 «ENDIF»
 578                 «IF isStatusDeprecated»
 579                     status «groupingDef.status»;
 580                 «ENDIF»
 581                 «IF !groupingDef.unknownSchemaNodes.nullOrEmpty»
 582                     «writeUnknownSchemaNodes(groupingDef.unknownSchemaNodes)»
 583                 «ENDIF»
 584             }
 585         '''
 586     }
 587
 588     def static writeContSchemaNode(ContainerSchemaNode contSchemaNode) {
 589         var boolean isStatusDeprecated = contSchemaNode.status == Status::DEPRECATED
 590         '''
 591             container «contSchemaNode.getQName.localName» {
 592                 «IF !contSchemaNode.childNodes.nullOrEmpty»
 593                 «writeDataSchemaNodes(contSchemaNode.childNodes)»
 594                 «ENDIF»
 595                 «IF !contSchemaNode.availableAugmentations.nullOrEmpty»
 596                 «writeAugments(contSchemaNode.availableAugmentations)»
 597                 «ENDIF»
 598                 «IF !contSchemaNode.groupings.nullOrEmpty»
 599                 «writeGroupingDefs(contSchemaNode.groupings)»
 600                 «ENDIF»
 601                 «IF !contSchemaNode.uses.nullOrEmpty»
 602                 «writeUsesNodes(contSchemaNode.uses)»
 603                 «ENDIF»
 604                 «IF isStatusDeprecated»
 605                 status «contSchemaNode.status»;
 606                 «ENDIF»
 607                 «IF !contSchemaNode.unknownSchemaNodes.nullOrEmpty»
 608                 «writeUnknownSchemaNodes(contSchemaNode.unknownSchemaNodes)»
 609                 «ENDIF»
 610             }
 611         '''
 612     }
 613
 614     def static writeAnyXmlSchemaNode(AnyXmlSchemaNode anyXmlSchemaNode) {
 615         var boolean isStatusDeprecated = anyXmlSchemaNode.status == Status::DEPRECATED
 616         '''
 617             anyxml «anyXmlSchemaNode.getQName.localName»«IF !isStatusDeprecated»;«ELSE» {
 618                 status «anyXmlSchemaNode.status»;
 619             }
 620             «ENDIF»
 621         '''
 622     }
 623
 624     def static writeLeafSchemaNode(LeafSchemaNode leafSchemaNode) {
 625         var boolean isStatusDeprecated = leafSchemaNode.status == Status::DEPRECATED
 626         '''
 627             leaf «leafSchemaNode.getQName.localName» {
 628                 type «leafSchemaNode.type.getQName.localName»;
 629                 «IF isStatusDeprecated»
 630                     status «leafSchemaNode.status»;
 631                 «ENDIF»
 632             }
 633         '''
 634     }
 635
 636     def static writeLeafListSchemaNode(LeafListSchemaNode leafListSchemaNode) {
 637         var boolean isStatusDeprecated = leafListSchemaNode.status == Status::DEPRECATED
 638         '''
 639             leaf-list «leafListSchemaNode.getQName.localName» {
 640                 type «leafListSchemaNode.type.getQName.localName»;
 641                 «IF isStatusDeprecated»
 642                     status «leafListSchemaNode.status»;
 643                 «ENDIF»
 644             }
 645         '''
 646     }
 647
 648     def static writeChoiceCaseNode(ChoiceCaseNode choiceCaseNode) {
 649         var boolean isStatusDeprecated = choiceCaseNode.status == Status::DEPRECATED
 650         '''
 651             case «choiceCaseNode.getQName.localName» {
 652                 «FOR childNode : choiceCaseNode.childNodes»
 653                     «writeDataSchemaNode(childNode)»
 654                 «ENDFOR»
 655                 «IF isStatusDeprecated»
 656                     status «choiceCaseNode.status»;
 657                 «ENDIF»
 658             }
 659         '''
 660     }
 661
 662     def static writeChoiceNode(ChoiceSchemaNode choiceNode) {
 663         var boolean isStatusDeprecated = choiceNode.status == Status::DEPRECATED
 664         '''
 665             choice «choiceNode.getQName.localName» {
 666                 «FOR child : choiceNode.cases»
 667                     «writeDataSchemaNode(child)»
 668                 «ENDFOR»
 669                 «IF isStatusDeprecated»
 670                     status «choiceNode.status»;
 671                 «ENDIF»
 672             }
 673         '''
 674     }
 675
 676     def static writeListSchemaNode(ListSchemaNode listSchemaNode) {
 677         var boolean isStatusDeprecated = listSchemaNode.status == Status::DEPRECATED
 678
 679         '''
 680             list «listSchemaNode.getQName.localName» {
 681                 key «FOR listKey : listSchemaNode.keyDefinition SEPARATOR " "»"«listKey.localName»"
 682                 «ENDFOR»
 683                 «IF !listSchemaNode.childNodes.nullOrEmpty»
 684                     «writeDataSchemaNodes(listSchemaNode.childNodes)»
 685                 «ENDIF»
 686                 «IF !listSchemaNode.availableAugmentations.nullOrEmpty»
 687                     «writeAugments(listSchemaNode.availableAugmentations)»
 688                 «ENDIF»
 689                 «IF !listSchemaNode.groupings.nullOrEmpty»
 690                     «writeGroupingDefs(listSchemaNode.groupings)»
 691                 «ENDIF»
 692                 «IF !listSchemaNode.uses.nullOrEmpty»
 693                     «writeUsesNodes(listSchemaNode.uses)»
 694                 «ENDIF»
 695                 «IF isStatusDeprecated»
 696                     status «listSchemaNode.status»;
 697                 «ENDIF»
 698                 «IF !listSchemaNode.unknownSchemaNodes.nullOrEmpty»
 699                     «writeUnknownSchemaNodes(listSchemaNode.unknownSchemaNodes)»
 700                 «ENDIF»
 701             }
 702         '''
 703     }
 704
 705     def static CharSequence writeDataSchemaNode(DataSchemaNode child) {
 706         '''
 707             «IF child instanceof ContainerSchemaNode»
 708                 «writeContSchemaNode(child)»
 709             «ENDIF»
 710             «IF child instanceof AnyXmlSchemaNode»
 711                 «writeAnyXmlSchemaNode(child)»
 712             «ENDIF»
 713             «IF child instanceof LeafSchemaNode»
 714                 «writeLeafSchemaNode(child)»
 715             «ENDIF»
 716             «IF child instanceof LeafListSchemaNode»
 717                 «writeLeafListSchemaNode(child)»
 718             «ENDIF»
 719             «IF child instanceof ChoiceCaseNode»
 720                 «writeChoiceCaseNode(child)»
 721             «ENDIF»
 722             «IF child instanceof ChoiceSchemaNode»
 723                 «writeChoiceNode(child)»
 724             «ENDIF»
 725             «IF child instanceof ListSchemaNode»
 726                 «writeListSchemaNode(child)»
 727             «ENDIF»
 728         '''
 729     }
 730
 731     static def String formatSchemaPath(String moduleName, Iterable<QName> schemaPath) {
 732         var currentElement = schemaPath.head
 733         val StringBuilder sb = new StringBuilder()
 734         sb.append(moduleName)
 735
 736         for(pathElement : schemaPath) {
 737             if(!currentElement.namespace.equals(pathElement.namespace)) {
 738                 currentElement = pathElement
 739                 sb.append('/')
 740                 sb.append(pathElement)
 741             }
 742             else {
 743                 sb.append('/')
 744                 sb.append(pathElement.localName)
 745             }
 746         }
 747         return sb.toString
 748     }
 749
 750     static def String formatToParagraph(String text, int nextLineIndent) {
 751         if (text == null || text.isEmpty())
 752             return '';
 753
 754         var String formattedText = text;
 755         val StringBuilder sb = new StringBuilder();
 756         val StringBuilder lineBuilder = new StringBuilder();
 757         var boolean isFirstElementOnNewLineEmptyChar = false;
 758         val lineIndent = computeNextLineIndent(nextLineIndent);
 759
 760         formattedText = NEWLINE_OR_TAB.removeFrom(formattedText);
 761         formattedText = formattedText.replaceAll(" +", " ");
 762
 763         val StringTokenizer tokenizer = new StringTokenizer(formattedText, " ", true);
 764
 765         while (tokenizer.hasMoreElements()) {
 766             val String nextElement = tokenizer.nextElement().toString();
 767
 768             if (lineBuilder.length() + nextElement.length() > 80) {
 769                 if (lineBuilder.charAt(lineBuilder.length() - 1) == ' ') {
 770                     lineBuilder.setLength(0);
 771                     lineBuilder.append(lineBuilder.substring(0, lineBuilder.length() - 1));
 772                 }
 773                 if (lineBuilder.charAt(0) == ' ') {
 774                     lineBuilder.setLength(0);
 775                     lineBuilder.append(lineBuilder.substring(1));
 776                 }
 777
 778                 sb.append(lineBuilder);
 779                 lineBuilder.setLength(0);
 780                 sb.append("\n");
 781
 782                 if (nextLineIndent > 0) {
 783                     sb.append(lineIndent)
 784                 }
 785
 786                 if (nextElement.toString().equals(" "))
 787                     isFirstElementOnNewLineEmptyChar = !isFirstElementOnNewLineEmptyChar;
 788             }
 789             if (isFirstElementOnNewLineEmptyChar) {
 790                 isFirstElementOnNewLineEmptyChar = !isFirstElementOnNewLineEmptyChar;
 791             } else {
 792                 lineBuilder.append(nextElement);
 793             }
 794         }
 795         sb.append(lineBuilder);
 796         sb.append("\n");
 797
 798         return sb.toString();
 799     }
 800
 801     def private static formatToAugmentPath(Iterable<QName> schemaPath) {
 802         val StringBuilder sb = new StringBuilder();
 803
 804         for(pathElement : schemaPath) {
 805             val ns = pathElement.namespace
 806             val localName = pathElement.localName
 807
 808             sb.append("\\(")
 809             sb.append(ns)
 810             sb.append(')')
 811             sb.append(localName)
 812         }
 813         return sb.toString
 814     }
 815
 816     private static def computeNextLineIndent(int nextLineIndent) {
 817         val StringBuilder sb = new StringBuilder()
 818         var i = 0
 819         while (i < nextLineIndent) {
 820             sb.append(' ')
 821             i = i + 1
 822         }
 823         return sb.toString
 824     }
 825 }