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