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