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