yang/yang-model-export/src/main/java/org/opendaylight/yangtools/yang/model/export/SchemaToStatementWriterAdaptor.java

   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.yang.model.export;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.annotations.Beta;
  13 import com.google.common.collect.Iterables;
  14 import com.google.common.primitives.UnsignedInteger;
  15 import java.net.URI;
  16 import java.util.Collection;
  17 import java.util.Iterator;
  18 import java.util.List;
  19 import javax.annotation.concurrent.NotThreadSafe;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.common.Revision;
  22 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
  23 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  24 import org.opendaylight.yangtools.yang.model.api.Status;
  25 import org.opendaylight.yangtools.yang.model.api.UniqueConstraint;
  26 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
  27 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
  29 import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
  30
  31 @Deprecated
  32 @Beta
  33 @NotThreadSafe
  34 final class SchemaToStatementWriterAdaptor implements YangModuleWriter {
  35
  36     private final StatementTextWriter writer;
  37
  38     private SchemaToStatementWriterAdaptor(final StatementTextWriter writer) {
  39         this.writer = requireNonNull(writer);
  40     }
  41
  42     public static YangModuleWriter from(final StatementTextWriter writer) {
  43         return new SchemaToStatementWriterAdaptor(writer);
  44     }
  45
  46     @Override
  47     public void endNode() {
  48         writer.endStatement();
  49     }
  50
  51     @Override
  52     public void startActionNode(final QName qname) {
  53         writer.startStatement(YangStmtMapping.ACTION);
  54         writer.writeArgument(qname);
  55     }
  56
  57     @Override
  58     public void startActionNode(final String rawArgument) {
  59         writer.startStatement(YangStmtMapping.ACTION);
  60         writer.writeArgument(rawArgument);
  61     }
  62
  63     @Override
  64     public void startAnydataNode(final QName qname) {
  65         writer.startStatement(YangStmtMapping.ANYDATA);
  66         writer.writeArgument(qname);
  67     }
  68
  69     @Override
  70     public void startAnydataNode(final String rawArgument) {
  71         writer.startStatement(YangStmtMapping.ANYDATA);
  72         writer.writeArgument(rawArgument);
  73     }
  74
  75     @Override
  76     public void startAnyxmlNode(final QName qname) {
  77         writer.startStatement(YangStmtMapping.ANYXML);
  78         writer.writeArgument(qname);
  79     }
  80
  81     @Override
  82     public void startAnyxmlNode(final String rawArgument) {
  83         writer.startStatement(YangStmtMapping.ANYXML);
  84         writer.writeArgument(rawArgument);
  85     }
  86
  87     @Override
  88     public void startArgumentNode(final String input) {
  89         writer.startStatement(YangStmtMapping.ARGUMENT);
  90         writer.writeArgument(input);
  91     }
  92
  93     @Override
  94     public void startAugmentNode(final SchemaPath targetPath) {
  95         writer.startStatement(YangStmtMapping.AUGMENT);
  96         writer.writeArgument(targetPath);
  97     }
  98
  99     @Override
 100     public void startAugmentNode(final String rawArgument) {
 101         writer.startStatement(YangStmtMapping.AUGMENT);
 102         writer.writeArgument(rawArgument);
 103     }
 104
 105     @Override
 106     public void startBaseNode(final QName qname) {
 107         writer.startStatement(YangStmtMapping.BASE);
 108         writer.writeArgument(qname);
 109     }
 110
 111     @Override
 112     public void startBaseNode(final String rawArgument) {
 113         writer.startStatement(YangStmtMapping.BASE);
 114         writer.writeArgument(rawArgument);
 115     }
 116
 117     @Override
 118     public void startBelongsToNode(final String rawArgument) {
 119         writer.startStatement(YangStmtMapping.BELONGS_TO);
 120         writer.writeArgument(rawArgument);
 121     }
 122
 123     @Override
 124     public void startBitNode(final String name) {
 125         writer.startStatement(YangStmtMapping.BIT);
 126         writer.writeArgument(name);
 127     }
 128
 129     @Override
 130     public void startCaseNode(final QName qname) {
 131         writer.startStatement(YangStmtMapping.CASE);
 132         writer.writeArgument(qname);
 133     }
 134
 135     @Override
 136     public void startCaseNode(final String rawArgument) {
 137         writer.startStatement(YangStmtMapping.CASE);
 138         writer.writeArgument(rawArgument);
 139     }
 140
 141     @Override
 142     public void startChoiceNode(final QName qname) {
 143         writer.startStatement(YangStmtMapping.CHOICE);
 144         writer.writeArgument(qname);
 145     }
 146
 147     @Override
 148     public void startChoiceNode(final String rawArgument) {
 149         writer.startStatement(YangStmtMapping.CHOICE);
 150         writer.writeArgument(rawArgument);
 151     }
 152
 153     @Override
 154     public void startConfigNode(final boolean config) {
 155         writer.startStatement(YangStmtMapping.CONFIG);
 156         writer.writeArgument(Boolean.toString(config));
 157     }
 158
 159     @Override
 160     public void startConfigNode(final String rawArgument) {
 161         writer.startStatement(YangStmtMapping.CONFIG);
 162         writer.writeArgument(rawArgument);
 163     }
 164
 165     @Override
 166     public void startContactNode(final String input) {
 167         writer.startStatement(YangStmtMapping.CONTACT);
 168         writer.writeArgument(input);
 169     }
 170
 171     @Override
 172     public void startContainerNode(final QName qname) {
 173         writer.startStatement(YangStmtMapping.CONTAINER);
 174         writer.writeArgument(qname);
 175     }
 176
 177     @Override
 178     public void startContainerNode(final String rawArgument) {
 179         writer.startStatement(YangStmtMapping.CONTAINER);
 180         writer.writeArgument(rawArgument);
 181     }
 182
 183     @Override
 184     public void startDefaultNode(final String string) {
 185         writer.startStatement(YangStmtMapping.DEFAULT);
 186         writer.writeArgument(string);
 187     }
 188
 189     @Override
 190     public void startDescriptionNode(final String input) {
 191         writer.startStatement(YangStmtMapping.DESCRIPTION);
 192         writer.writeArgument(input);
 193     }
 194
 195     @Override
 196     public void startDeviateNode(final String rawArgument) {
 197         writer.startStatement(YangStmtMapping.DEVIATE);
 198         writer.writeArgument(rawArgument);
 199     }
 200
 201     @Override
 202     public void startDeviationNode(final String rawArgument) {
 203         writer.startStatement(YangStmtMapping.DEVIATION);
 204         writer.writeArgument(rawArgument);
 205     }
 206
 207     @Override
 208     public void startEnumNode(final String name) {
 209         writer.startStatement(YangStmtMapping.ENUM);
 210         writer.writeArgument(name);
 211     }
 212
 213     @Override
 214     public void startErrorAppTagNode(final String input) {
 215         writer.startStatement(YangStmtMapping.ERROR_APP_TAG);
 216         writer.writeArgument(input);
 217     }
 218
 219     @Override
 220     public void startErrorMessageNode(final String input) {
 221         writer.startStatement(YangStmtMapping.ERROR_MESSAGE);
 222         writer.writeArgument(input);
 223     }
 224
 225     @Override
 226     public void startExtensionNode(final QName qname) {
 227         writer.startStatement(YangStmtMapping.EXTENSION);
 228         writer.writeArgument(qname);
 229     }
 230
 231     @Override
 232     public void startExtensionNode(final String rawArgument) {
 233         writer.startStatement(YangStmtMapping.EXTENSION);
 234         writer.writeArgument(rawArgument);
 235     }
 236
 237     @Override
 238     public void startFeatureNode(final QName qname) {
 239         writer.startStatement(YangStmtMapping.FEATURE);
 240         writer.writeArgument(qname);
 241     }
 242
 243     @Override
 244     public void startFeatureNode(final String rawArgument) {
 245         writer.startStatement(YangStmtMapping.FEATURE);
 246         writer.writeArgument(rawArgument);
 247     }
 248
 249     @Override
 250     public void startFractionDigitsNode(final Integer fractionDigits) {
 251         writer.startStatement(YangStmtMapping.FRACTION_DIGITS);
 252         writer.writeArgument(fractionDigits.toString());
 253     }
 254
 255     @Override
 256     public void startFractionDigitsNode(final String rawArgument) {
 257         writer.startStatement(YangStmtMapping.FRACTION_DIGITS);
 258         writer.writeArgument(rawArgument);
 259     }
 260
 261     @Override
 262     public void startGroupingNode(final QName qname) {
 263         writer.startStatement(YangStmtMapping.GROUPING);
 264         writer.writeArgument(qname);
 265     }
 266
 267     @Override
 268     public void startGroupingNode(final String rawArgument) {
 269         writer.startStatement(YangStmtMapping.GROUPING);
 270         writer.writeArgument(rawArgument);
 271     }
 272
 273     @Override
 274     public void startIdentityNode(final QName qname) {
 275         writer.startStatement(YangStmtMapping.IDENTITY);
 276         writer.writeArgument(qname);
 277     }
 278
 279     @Override
 280     public void startIdentityNode(final String rawArgument) {
 281         writer.startStatement(YangStmtMapping.IDENTITY);
 282         writer.writeArgument(rawArgument);
 283     }
 284
 285     @Override
 286     public void startIfFeatureNode(final String rawArgument) {
 287         writer.startStatement(YangStmtMapping.IF_FEATURE);
 288         writer.writeArgument(rawArgument);
 289     }
 290
 291     @Override
 292     public void startImportNode(final String moduleName) {
 293         writer.startStatement(YangStmtMapping.IMPORT);
 294         writer.writeArgument(moduleName);
 295     }
 296
 297     @Override
 298     public void startIncludeNode(final String rawArgument) {
 299         writer.startStatement(YangStmtMapping.INCLUDE);
 300         writer.writeArgument(rawArgument);
 301     }
 302
 303     @Override
 304     public void startInputNode() {
 305         writer.startStatement(YangStmtMapping.INPUT);
 306     }
 307
 308     @Override
 309     public void startKeyNode(final List<QName> keyList) {
 310         writer.startStatement(YangStmtMapping.KEY);
 311         final StringBuilder keyStr = new StringBuilder();
 312         final Iterator<QName> iter = keyList.iterator();
 313         while (iter.hasNext()) {
 314             keyStr.append(iter.next().getLocalName());
 315             if (iter.hasNext()) {
 316                 keyStr.append(' ');
 317             }
 318         }
 319         writer.writeArgument(keyStr.toString());
 320     }
 321
 322     @Override
 323     public void startKeyNode(final String rawArgument) {
 324         writer.startStatement(YangStmtMapping.KEY);
 325         writer.writeArgument(rawArgument);
 326     }
 327
 328     @Override
 329     public void startLeafListNode(final QName qname) {
 330         writer.startStatement(YangStmtMapping.LEAF_LIST);
 331         writer.writeArgument(qname);
 332     }
 333
 334     @Override
 335     public void startLeafListNode(final String rawArgument) {
 336         writer.startStatement(YangStmtMapping.LEAF_LIST);
 337         writer.writeArgument(rawArgument);
 338     }
 339
 340     @Override
 341     public void startLeafNode(final QName qname) {
 342         writer.startStatement(YangStmtMapping.LEAF);
 343         writer.writeArgument(qname);
 344     }
 345
 346     @Override
 347     public void startLeafNode(final String rawArgument) {
 348         writer.startStatement(YangStmtMapping.LEAF);
 349         writer.writeArgument(rawArgument);
 350     }
 351
 352     @Override
 353     public void startLengthNode(final String lengthString) {
 354         writer.startStatement(YangStmtMapping.LENGTH);
 355         writer.writeArgument(lengthString);
 356     }
 357
 358     @Override
 359     public void startListNode(final QName qname) {
 360         writer.startStatement(YangStmtMapping.LIST);
 361         writer.writeArgument(qname);
 362     }
 363
 364     @Override
 365     public void startListNode(final String rawArgument) {
 366         writer.startStatement(YangStmtMapping.LIST);
 367         writer.writeArgument(rawArgument);
 368     }
 369
 370     @Override
 371     public void startMandatoryNode(final boolean mandatory) {
 372         writer.startStatement(YangStmtMapping.MANDATORY);
 373         writer.writeArgument(Boolean.toString(mandatory));
 374     }
 375
 376     @Override
 377     public void startMandatoryNode(final String rawArgument) {
 378         writer.startStatement(YangStmtMapping.MANDATORY);
 379         writer.writeArgument(rawArgument);
 380     }
 381
 382     @Override
 383     public void startMaxElementsNode(final Integer max) {
 384         writer.startStatement(YangStmtMapping.MAX_ELEMENTS);
 385         writer.writeArgument(max.toString());
 386     }
 387
 388     @Override
 389     public void startMaxElementsNode(final String rawArgument) {
 390         writer.startStatement(YangStmtMapping.MAX_ELEMENTS);
 391         writer.writeArgument(rawArgument);
 392     }
 393
 394     @Override
 395     public void startMinElementsNode(final Integer min) {
 396         writer.startStatement(YangStmtMapping.MIN_ELEMENTS);
 397         writer.writeArgument(min.toString());
 398     }
 399
 400     @Override
 401     public void startMinElementsNode(final String rawArgument) {
 402         writer.startStatement(YangStmtMapping.MIN_ELEMENTS);
 403         writer.writeArgument(rawArgument);
 404     }
 405
 406     @Override
 407     public void startModifierNode(final ModifierKind modifier) {
 408         writer.startStatement(YangStmtMapping.MODIFIER);
 409         writer.writeArgument(modifier.getKeyword());
 410     }
 411
 412     @Override
 413     public void startModifierNode(final String rawArgument) {
 414         writer.startStatement(YangStmtMapping.MODIFIER);
 415         writer.writeArgument(rawArgument);
 416     }
 417
 418     @Override
 419     public void startModuleNode(final String identifier) {
 420         writer.startStatement(YangStmtMapping.MODULE);
 421         writer.writeArgument(identifier);
 422     }
 423
 424     @Override
 425     public void startMustNode(final RevisionAwareXPath xpath) {
 426         writer.startStatement(YangStmtMapping.MUST);
 427         writer.writeArgument(xpath);
 428     }
 429
 430     @Override
 431     public void startMustNode(final String rawArgument) {
 432         writer.startStatement(YangStmtMapping.MUST);
 433         writer.writeArgument(rawArgument);
 434     }
 435
 436     @Override
 437     public void startNamespaceNode(final URI uri) {
 438         writer.startStatement(YangStmtMapping.NAMESPACE);
 439         writer.writeArgument(uri.toString());
 440     }
 441
 442     @Override
 443     public void startNotificationNode(final QName qname) {
 444         writer.startStatement(YangStmtMapping.NOTIFICATION);
 445         writer.writeArgument(qname);
 446     }
 447
 448     @Override
 449     public void startNotificationNode(final String rawArgument) {
 450         writer.startStatement(YangStmtMapping.NOTIFICATION);
 451         writer.writeArgument(rawArgument);
 452     }
 453
 454     @Override
 455     public void startOrderedByNode(final String ordering) {
 456         writer.startStatement(YangStmtMapping.ORDERED_BY);
 457         writer.writeArgument(ordering);
 458     }
 459
 460     @Override
 461     public void startOrganizationNode(final String input) {
 462         writer.startStatement(YangStmtMapping.ORGANIZATION);
 463         writer.writeArgument(input);
 464     }
 465
 466     @Override
 467     public void startOutputNode() {
 468         writer.startStatement(YangStmtMapping.OUTPUT);
 469     }
 470
 471     @Override
 472     public void startPathNode(final RevisionAwareXPath revisionAwareXPath) {
 473         writer.startStatement(YangStmtMapping.PATH);
 474         writer.writeArgument(revisionAwareXPath);
 475     }
 476
 477     @Override
 478     public void startPathNode(final String rawArgument) {
 479         writer.startStatement(YangStmtMapping.PATH);
 480         writer.writeArgument(rawArgument);
 481     }
 482
 483     @Override
 484     public void startPatternNode(final String regularExpression) {
 485         writer.startStatement(YangStmtMapping.PATTERN);
 486         writer.writeArgument(regularExpression);
 487     }
 488
 489     @Override
 490     public void startPositionNode(final UnsignedInteger position) {
 491         writer.startStatement(YangStmtMapping.POSITION);
 492         writer.writeArgument(position.toString());
 493     }
 494
 495     @Override
 496     public void startPositionNode(final String rawArgument) {
 497         writer.startStatement(YangStmtMapping.POSITION);
 498         writer.writeArgument(rawArgument);
 499     }
 500
 501     @Override
 502     public void startPrefixNode(final String input) {
 503         writer.startStatement(YangStmtMapping.PREFIX);
 504         writer.writeArgument(input);
 505     }
 506
 507     @Override
 508     public void startPresenceNode(final boolean presence) {
 509         writer.startStatement(YangStmtMapping.PRESENCE);
 510         writer.writeArgument(Boolean.toString(presence));
 511     }
 512
 513     @Override
 514     public void startPresenceNode(final String rawArgument) {
 515         writer.startStatement(YangStmtMapping.PRESENCE);
 516         writer.writeArgument(rawArgument);
 517     }
 518
 519     @Override
 520     public void startRangeNode(final String rangeString) {
 521         writer.startStatement(YangStmtMapping.RANGE);
 522         writer.writeArgument(rangeString);
 523     }
 524
 525     @Override
 526     public void startReferenceNode(final String input) {
 527         writer.startStatement(YangStmtMapping.REFERENCE);
 528         writer.writeArgument(input);
 529     }
 530
 531     @Override
 532     public void startRefineNode(final SchemaPath path) {
 533         writer.startStatement(YangStmtMapping.REFINE);
 534         writer.writeArgument(path);
 535     }
 536
 537     @Override
 538     public void startRefineNode(final String rawArgument) {
 539         writer.startStatement(YangStmtMapping.REFINE);
 540         writer.writeArgument(rawArgument);
 541     }
 542
 543     @Override
 544     public void startRequireInstanceNode(final boolean require) {
 545         writer.startStatement(YangStmtMapping.REQUIRE_INSTANCE);
 546         writer.writeArgument(Boolean.toString(require));
 547     }
 548
 549     @Override
 550     public void startRequireInstanceNode(final String rawArgument) {
 551         writer.startStatement(YangStmtMapping.REQUIRE_INSTANCE);
 552         writer.writeArgument(rawArgument);
 553     }
 554
 555     @Override
 556     public void startRevisionDateNode(final Revision date) {
 557         writer.startStatement(YangStmtMapping.REVISION_DATE);
 558         writer.writeArgument(date.toString());
 559     }
 560
 561     @Override
 562     public void startRevisionDateNode(final String rawArgument) {
 563         writer.startStatement(YangStmtMapping.REVISION_DATE);
 564         writer.writeArgument(rawArgument);
 565     }
 566
 567     @Override
 568     public void startRevisionNode(final Revision date) {
 569         writer.startStatement(YangStmtMapping.REVISION);
 570         writer.writeArgument(date.toString());
 571     }
 572
 573     @Override
 574     public void startRevisionNode(final String rawArgument) {
 575         writer.startStatement(YangStmtMapping.REVISION);
 576         writer.writeArgument(rawArgument);
 577     }
 578
 579     @Override
 580     public void startRpcNode(final QName qname) {
 581         writer.startStatement(YangStmtMapping.RPC);
 582         writer.writeArgument(qname);
 583     }
 584
 585     @Override
 586     public void startRpcNode(final String rawArgument) {
 587         writer.startStatement(YangStmtMapping.RPC);
 588         writer.writeArgument(rawArgument);
 589     }
 590
 591     @Override
 592     public void startStatusNode(final Status status) {
 593         writer.startStatement(YangStmtMapping.STATUS);
 594         writer.writeArgument(status.toString().toLowerCase());
 595     }
 596
 597     @Override
 598     public void startStatusNode(final String rawArgument) {
 599         writer.startStatement(YangStmtMapping.STATUS);
 600         writer.writeArgument(rawArgument);
 601     }
 602
 603     @Override
 604     public void startSubmoduleNode(final String rawArgument) {
 605         writer.startStatement(YangStmtMapping.SUBMODULE);
 606         writer.writeArgument(rawArgument);
 607     }
 608
 609     @Override
 610     public void startTypeNode(final QName qname) {
 611         writer.startStatement(YangStmtMapping.TYPE);
 612         writer.writeArgument(qname);
 613     }
 614
 615     @Override
 616     public void startTypeNode(final String rawArgument) {
 617         writer.startStatement(YangStmtMapping.TYPE);
 618         writer.writeArgument(rawArgument);
 619     }
 620
 621     @Override
 622     public void startTypedefNode(final QName qname) {
 623         writer.startStatement(YangStmtMapping.TYPEDEF);
 624         writer.writeArgument(qname);
 625     }
 626
 627     @Override
 628     public void startTypedefNode(final String rawArgument) {
 629         writer.startStatement(YangStmtMapping.TYPEDEF);
 630         writer.writeArgument(rawArgument);
 631     }
 632
 633     @Override
 634     public void startUniqueNode(final UniqueConstraint uniqueConstraint) {
 635         writer.startStatement(YangStmtMapping.UNIQUE);
 636         final StringBuilder uniqueStr = new StringBuilder();
 637         final Collection<Relative> tag = uniqueConstraint.getTag();
 638
 639         final Iterator<Relative> iter = tag.iterator();
 640         while (iter.hasNext()) {
 641             uniqueStr.append(
 642                     String.join("/", Iterables.transform(iter.next().getPathFromRoot(), qn -> qn.getLocalName())));
 643             if (iter.hasNext()) {
 644                 uniqueStr.append(' ');
 645             }
 646         }
 647         writer.writeArgument(uniqueStr.toString());
 648     }
 649
 650     @Override
 651     public void startUniqueNode(final String rawArgument) {
 652         writer.startStatement(YangStmtMapping.UNIQUE);
 653         writer.writeArgument(rawArgument);
 654     }
 655
 656     @Override
 657     public void startUnitsNode(final String input) {
 658         writer.startStatement(YangStmtMapping.UNITS);
 659         writer.writeArgument(input);
 660     }
 661
 662     @Override
 663     public void startUnknownNode(final StatementDefinition def) {
 664         writer.startStatement(def);
 665     }
 666
 667     @Override
 668     public void startUnknownNode(final StatementDefinition def, final String nodeParameter) {
 669         writer.startStatement(def);
 670         writer.writeArgument(nodeParameter);
 671     }
 672
 673     @Override
 674     public void startUsesNode(final QName groupingName) {
 675         writer.startStatement(YangStmtMapping.USES);
 676         writer.writeArgument(groupingName);
 677     }
 678
 679     @Override
 680     public void startUsesNode(final String rawArgument) {
 681         writer.startStatement(YangStmtMapping.USES);
 682         writer.writeArgument(rawArgument);
 683     }
 684
 685     @Override
 686     public void startValueNode(final Integer integer) {
 687         writer.startStatement(YangStmtMapping.VALUE);
 688         writer.writeArgument(integer.toString());
 689     }
 690
 691     @Override
 692     public void startValueNode(final String rawArgument) {
 693         writer.startStatement(YangStmtMapping.VALUE);
 694         writer.writeArgument(rawArgument);
 695     }
 696
 697     @Override
 698     public void startWhenNode(final RevisionAwareXPath revisionAwareXPath) {
 699         writer.startStatement(YangStmtMapping.WHEN);
 700         writer.writeArgument(revisionAwareXPath);
 701     }
 702
 703     @Override
 704     public void startWhenNode(final String rawArgument) {
 705         writer.startStatement(YangStmtMapping.WHEN);
 706         writer.writeArgument(rawArgument);
 707     }
 708
 709     @Override
 710     public void startYangVersionNode(final String input) {
 711         writer.startStatement(YangStmtMapping.YANG_VERSION);
 712         writer.writeArgument(input);
 713     }
 714
 715     @Override
 716     public void startYinElementNode(final boolean yinElement) {
 717         writer.startStatement(YangStmtMapping.YIN_ELEMENT);
 718         writer.writeArgument(Boolean.toString(yinElement));
 719     }
 720
 721     @Override
 722     public void startYinElementNode(final String rawArgument) {
 723         writer.startStatement(YangStmtMapping.YIN_ELEMENT);
 724         writer.writeArgument(rawArgument);
 725     }
 726 }