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