yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/DeclaredStatements.java

   1 /*
   2  * Copyright (c) 2021 PANTHEON.tech, s.r.o. 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.spi.stmt;
   9
  10 import com.google.common.annotations.Beta;
  11 import com.google.common.collect.ImmutableList;
  12 import java.util.List;
  13 import java.util.Set;
  14 import org.eclipse.jdt.annotation.NonNullByDefault;
  15 import org.opendaylight.yangtools.yang.common.Ordering;
  16 import org.opendaylight.yangtools.yang.common.QName;
  17 import org.opendaylight.yangtools.yang.common.Revision;
  18 import org.opendaylight.yangtools.yang.common.Uint32;
  19 import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
  20 import org.opendaylight.yangtools.yang.common.XMLNamespace;
  21 import org.opendaylight.yangtools.yang.common.YangVersion;
  22 import org.opendaylight.yangtools.yang.model.api.DeviateKind;
  23 import org.opendaylight.yangtools.yang.model.api.PathExpression;
  24 import org.opendaylight.yangtools.yang.model.api.Status;
  25 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  26 import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
  27 import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
  28 import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
  29 import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
  30 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
  31 import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
  32 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
  33 import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
  34 import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
  35 import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
  36 import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
  37 import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
  38 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
  39 import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
  40 import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
  41 import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
  42 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
  43 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
  44 import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
  45 import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
  46 import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
  47 import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
  48 import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
  49 import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureExpr;
  50 import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
  51 import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
  52 import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
  53 import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
  54 import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
  55 import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
  56 import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement;
  57 import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
  58 import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
  59 import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
  60 import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
  61 import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
  62 import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
  63 import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
  64 import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
  65 import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
  66 import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
  67 import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
  68 import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
  69 import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
  70 import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
  71 import org.opendaylight.yangtools.yang.model.api.stmt.PatternExpression;
  72 import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
  73 import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
  74 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
  75 import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
  76 import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
  77 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
  78 import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
  79 import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
  80 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
  81 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
  82 import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
  83 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
  84 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
  85 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
  86 import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
  87 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
  88 import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
  89 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
  90 import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
  91 import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
  92 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
  93 import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
  94 import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
  95 import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
  96 import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
  97 import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
  98 import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
  99 import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
 100
 101 /**
 102  * Static entry point to instantiating {@link DeclaredStatement} covered in the {@code RFC7950} metamodel.
 103  */
 104 @Beta
 105 @NonNullByDefault
 106 public final class DeclaredStatements {
 107     private DeclaredStatements() {
 108         // Hidden on purpose
 109     }
 110
 111     public static ActionStatement createAction(final QName argument) {
 112         return new EmptyActionStatement(argument);
 113     }
 114
 115     public static ActionStatement createAction(final QName argument,
 116             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 117         return substatements.isEmpty() ? createAction(argument) : new RegularActionStatement(argument, substatements);
 118     }
 119
 120     public static AnydataStatement createAnydata(final QName argument) {
 121         return new EmptyAnydataStatement(argument);
 122     }
 123
 124     public static AnydataStatement createAnydata(final QName argument,
 125             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 126         return substatements.isEmpty() ? createAnydata(argument) : new RegularAnydataStatement(argument, substatements);
 127     }
 128
 129     public static AnyxmlStatement createAnyxml(final QName argument) {
 130         return new EmptyAnyxmlStatement(argument);
 131     }
 132
 133     public static AnyxmlStatement createAnyxml(final QName argument,
 134             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 135         return substatements.isEmpty() ? createAnyxml(argument) : new RegularAnyxmlStatement(argument, substatements);
 136     }
 137
 138     public static ArgumentStatement createArgument(final QName argument) {
 139         return new EmptyArgumentStatement(argument);
 140     }
 141
 142     public static ArgumentStatement createArgument(final QName argument,
 143             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 144         return substatements.isEmpty() ? createArgument(argument)
 145             : new RegularArgumentStatement(argument, substatements);
 146     }
 147
 148     public static AugmentStatement createAugment(final String rawArgument, final SchemaNodeIdentifier argument) {
 149         return new EmptyAugmentStatement(rawArgument, argument);
 150     }
 151
 152     public static AugmentStatement createAugment(final String rawArgument, final SchemaNodeIdentifier argument,
 153             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 154         return substatements.isEmpty() ? createAugment(rawArgument, argument)
 155             : new RegularAugmentStatement(rawArgument, argument, substatements);
 156     }
 157
 158     public static BaseStatement createBase(final QName argument) {
 159         return new EmptyBaseStatement(argument);
 160     }
 161
 162     public static BaseStatement createBase(final QName argument,
 163             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 164         return substatements.isEmpty() ? createBase(argument) : new RegularBaseStatement(argument, substatements);
 165     }
 166
 167     public static BelongsToStatement createBelongsTo(final String argument) {
 168         return new EmptyBelongsToStatement(argument);
 169     }
 170
 171     public static BelongsToStatement createBelongsTo(final String argument,
 172             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 173         return substatements.isEmpty() ? createBelongsTo(argument)
 174             : new RegularBelongsToStatement(argument, substatements);
 175     }
 176
 177     public static BitStatement createBit(final String argument) {
 178         return new EmptyBitStatement(argument);
 179     }
 180
 181     public static BitStatement createBit(final String argument,
 182             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 183         return substatements.isEmpty() ? createBit(argument) : new RegularBitStatement(argument, substatements);
 184     }
 185
 186     public static ChoiceStatement createChoice(final QName argument) {
 187         return new EmptyChoiceStatement(argument);
 188     }
 189
 190     public static ChoiceStatement createChoice(final QName argument,
 191             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 192         return substatements.isEmpty() ? createChoice(argument) : new RegularChoiceStatement(argument, substatements);
 193     }
 194
 195     public static ConfigStatement createConfig(final Boolean argument) {
 196         return new EmptyConfigStatement(argument);
 197     }
 198
 199     public static ConfigStatement createConfig(final Boolean argument,
 200             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 201         return substatements.isEmpty() ? createConfig(argument) : new RegularConfigStatement(argument, substatements);
 202     }
 203
 204     public static ContainerStatement createContainer(final QName argument) {
 205         return new EmptyContainerStatement(argument);
 206     }
 207
 208     public static ContainerStatement createContainer(final QName argument,
 209             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 210         return substatements.isEmpty() ? createContainer(argument)
 211             : new RegularContainerStatement(argument, substatements);
 212     }
 213
 214     public static DefaultStatement createDefault(final String argument) {
 215         return new EmptyDefaultStatement(argument);
 216     }
 217
 218     public static DefaultStatement createDefault(final String argument,
 219             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 220         return substatements.isEmpty() ? createDefault(argument) : new RegularDefaultStatement(argument, substatements);
 221     }
 222
 223     public static DescriptionStatement createDescription(final String argument) {
 224         return new EmptyDescriptionStatement(argument);
 225     }
 226
 227     public static DescriptionStatement createDescription(final String argument,
 228             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 229         return substatements.isEmpty() ? createDescription(argument)
 230             : new RegularDescriptionStatement(argument, substatements);
 231     }
 232
 233     public static DeviateStatement createDeviate(final DeviateKind argument) {
 234         // This is exceedingly unlikely, just reuse the implementation
 235         return createDeviate(argument, ImmutableList.of());
 236     }
 237
 238     public static DeviateStatement createDeviate(final DeviateKind argument,
 239             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 240         return new DeviateStatementImpl(argument, substatements);
 241     }
 242
 243     public static DeviationStatement createDeviation(final String rawArgument, final Absolute argument) {
 244         // This does not make really sense
 245         return createDeviation(rawArgument, argument, ImmutableList.of());
 246     }
 247
 248     public static DeviationStatement createDeviation(final String rawArgument, final Absolute argument,
 249             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 250         return new DeviationStatementImpl(rawArgument, argument, substatements);
 251     }
 252
 253     // FIXME: what is the distinction between rawArgument and argument?
 254     public static EnumStatement createEnum(final String rawArgument, final String argument) {
 255         return new EmptyEnumStatement(rawArgument, argument);
 256     }
 257
 258     public static EnumStatement createEnum(final String rawArgument, final String argument,
 259             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 260         return substatements.isEmpty() ? createEnum(rawArgument, argument)
 261             : new RegularEnumStatement(rawArgument, argument, substatements);
 262     }
 263
 264     public static ErrorAppTagStatement createErrorAppTag(final String argument) {
 265         return new EmptyErrorAppTagStatement(argument);
 266     }
 267
 268     public static ErrorAppTagStatement createErrorAppTag(final String argument,
 269             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 270         return substatements.isEmpty() ? createErrorAppTag(argument)
 271             : new RegularErrorAppTagStatement(argument, substatements);
 272     }
 273
 274     public static ErrorMessageStatement createErrorMessage(final String argument) {
 275         return new EmptyErrorMessageStatement(argument);
 276     }
 277
 278     public static ErrorMessageStatement createErrorMessage(final String argument,
 279             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 280         return substatements.isEmpty() ? createErrorMessage(argument)
 281             : new RegularErrorMessageStatement(argument, substatements);
 282     }
 283
 284     public static ExtensionStatement createExtension(final QName argument) {
 285         return new EmptyExtensionStatement(argument);
 286     }
 287
 288     public static ExtensionStatement createExtension(final QName argument,
 289             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 290         return substatements.isEmpty() ? createExtension(argument)
 291             : new RegularExtensionStatement(argument, substatements);
 292     }
 293
 294     public static FeatureStatement createFeature(final QName argument) {
 295         return new EmptyFeatureStatement(argument);
 296     }
 297
 298     public static FeatureStatement createFeature(final QName argument,
 299             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 300         return substatements.isEmpty() ? createFeature(argument) : new RegularFeatureStatement(argument, substatements);
 301     }
 302
 303     public static FractionDigitsStatement createFractionDigits(final Integer argument) {
 304         return new EmptyFractionDigitsStatement(argument);
 305     }
 306
 307     public static FractionDigitsStatement createFractionDigits(final Integer argument,
 308             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 309         return substatements.isEmpty() ? createFractionDigits(argument)
 310             : new RegularFractionDigitsStatement(argument, substatements);
 311     }
 312
 313     public static GroupingStatement createGrouping(final QName argument) {
 314         return new EmptyGroupingStatement(argument);
 315     }
 316
 317     public static GroupingStatement createGrouping(final QName argument,
 318             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 319         return substatements.isEmpty() ? createGrouping(argument)
 320             : new RegularGroupingStatement(argument, substatements);
 321     }
 322
 323     public static IdentityStatement createIdentity(final QName argument) {
 324         return new EmptyIdentityStatement(argument);
 325     }
 326
 327     public static IdentityStatement createIdentity(final QName argument,
 328             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 329         return substatements.isEmpty() ? createIdentity(argument)
 330             : new RegularIdentityStatement(argument, substatements);
 331     }
 332
 333     public static IfFeatureStatement createIfFeature(final String rawArgument, final IfFeatureExpr argument) {
 334         return new EmptyIfFeatureStatement(rawArgument, argument);
 335     }
 336
 337     public static IfFeatureStatement createIfFeature(final String rawArgument, final IfFeatureExpr argument,
 338             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 339         return substatements.isEmpty() ? createIfFeature(rawArgument, argument)
 340             : new RegularIfFeatureStatement(rawArgument, argument, substatements);
 341     }
 342
 343     public static ImportStatement createImport(final String argument) {
 344         // This should never happen
 345         return createImport(argument, ImmutableList.of());
 346     }
 347
 348     public static ImportStatement createImport(final String argument,
 349             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 350         return new ImportStatementImpl(argument, substatements);
 351     }
 352
 353     public static IncludeStatement createInclude(final String rawArgument, final String argument) {
 354         return new EmptyIncludeStatement(rawArgument, argument);
 355     }
 356
 357     public static IncludeStatement createInclude(final String rawArgument, final String argument,
 358             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 359         return substatements.isEmpty() ? createInclude(rawArgument, argument)
 360             : new RegularIncludeStatement(rawArgument, argument, substatements);
 361     }
 362
 363     public static InputStatement createInput(final QName argument) {
 364         return new EmptyInputStatement(argument);
 365     }
 366
 367     public static InputStatement createInput(final QName argument,
 368             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 369         return substatements.isEmpty() ? createInput(argument) : new RegularInputStatement(argument, substatements);
 370     }
 371
 372     public static KeyStatement createKey(final String rawArgument, final Set<QName> argument) {
 373         return new EmptyKeyStatement(rawArgument, argument);
 374     }
 375
 376     public static KeyStatement createKey(final String rawArgument, final Set<QName> argument,
 377             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 378         return substatements.isEmpty() ? createKey(rawArgument, argument)
 379             : new RegularKeyStatement(rawArgument, argument, substatements);
 380     }
 381
 382     public static LeafStatement createLeaf(final QName argument) {
 383         return new EmptyLeafStatement(argument);
 384     }
 385
 386     public static LeafStatement createLeaf(final QName argument,
 387             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 388         return substatements.isEmpty() ? createLeaf(argument) : new RegularLeafStatement(argument, substatements);
 389     }
 390
 391     public static LeafListStatement createLeafList(final QName argument) {
 392         return new EmptyLeafListStatement(argument);
 393     }
 394
 395     public static LeafListStatement createLeafList(final QName argument,
 396             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 397         return substatements.isEmpty() ? createLeafList(argument)
 398             : new RegularLeafListStatement(argument, substatements);
 399     }
 400
 401     public static LengthStatement createLength(final String rawArgument, final List<ValueRange> argument) {
 402         return new EmptyLengthStatement(rawArgument, argument);
 403     }
 404
 405     public static LengthStatement createLength(final String rawArgument, final List<ValueRange> argument,
 406             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 407         return substatements.isEmpty() ? createLength(rawArgument, argument)
 408             : new RegularLengthStatement(rawArgument, argument, substatements);
 409     }
 410
 411     public static ListStatement createList(final QName argument) {
 412         return new EmptyListStatement(argument);
 413     }
 414
 415     public static ListStatement createList(final QName argument,
 416             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 417         return substatements.isEmpty() ? createList(argument) : new RegularListStatement(argument, substatements);
 418     }
 419
 420     public static MandatoryStatement createMandatory(final Boolean argument) {
 421         return new EmptyMandatoryStatement(argument);
 422     }
 423
 424     public static MandatoryStatement createMandatory(final Boolean argument,
 425             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 426         return substatements.isEmpty() ? createMandatory(argument)
 427             : new RegularMandatoryStatement(argument, substatements);
 428     }
 429
 430     public static MaxElementsStatement createMaxElements(final String rawArgument, final String argument) {
 431         return new EmptyMaxElementsStatement(rawArgument, argument);
 432     }
 433
 434     public static MaxElementsStatement createMaxElements(final String rawArgument, final String argument,
 435             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 436         return substatements.isEmpty() ? createMaxElements(rawArgument, argument)
 437             : new RegularMaxElementsStatement(rawArgument, argument, substatements);
 438     }
 439
 440     public static MinElementsStatement createMinElements(final Integer argument) {
 441         return new EmptyMinElementsStatement(argument);
 442     }
 443
 444     public static MinElementsStatement createMinElements(final Integer argument,
 445             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 446         return substatements.isEmpty() ? createMinElements(argument)
 447             : new RegularMinElementsStatement(argument, substatements);
 448     }
 449
 450     public static ModifierStatement createModifier(final ModifierKind argument) {
 451         return new EmptyModifierStatement(argument);
 452     }
 453
 454     public static ModifierStatement createModifier(final ModifierKind argument,
 455             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 456         return substatements.isEmpty() ? createModifier(argument)
 457             : new RegularModifierStatement(argument, substatements);
 458     }
 459
 460     public static ModuleStatement createModule(final String rawArgument, final UnqualifiedQName argument,
 461             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 462         return new ModuleStatementImpl(rawArgument, argument, substatements);
 463     }
 464
 465     public static MustStatement createMust(final String rawArgument, final QualifiedBound argument) {
 466         return new EmptyMustStatement(rawArgument, argument);
 467     }
 468
 469     public static MustStatement createMust(final String rawArgument, final QualifiedBound argument,
 470             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 471         return substatements.isEmpty() ? createMust(rawArgument, argument)
 472             : new RegularMustStatement(rawArgument, argument, substatements);
 473     }
 474
 475     public static NamespaceStatement createNamespace(final XMLNamespace argument) {
 476         return new EmptyNamespaceStatement(argument);
 477     }
 478
 479     public static NamespaceStatement createNamespace(final XMLNamespace argument,
 480             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 481         return substatements.isEmpty() ? createNamespace(argument)
 482             : new RegularNamespaceStatement(argument, substatements);
 483     }
 484
 485     public static NotificationStatement createNotification(final QName argument) {
 486         return new EmptyNotificationStatement(argument);
 487     }
 488
 489     public static NotificationStatement createNotification(final QName argument,
 490             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 491         return substatements.isEmpty() ? createNotification(argument)
 492             : new RegularNotificationStatement(argument, substatements);
 493     }
 494
 495     public static OrganizationStatement createOrganization(final String argument) {
 496         return new EmptyOrganizationStatement(argument);
 497     }
 498
 499     public static OrganizationStatement createOrganization(final String argument,
 500             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 501         return substatements.isEmpty() ? createOrganization(argument)
 502             : new RegularOrganizationStatement(argument, substatements);
 503     }
 504
 505     public static OutputStatement createOutput(final QName argument) {
 506         return new EmptyOutputStatement(argument);
 507     }
 508
 509     public static OutputStatement createOutput(final QName argument,
 510             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 511         return substatements.isEmpty() ? createOutput(argument) : new RegularOutputStatement(argument, substatements);
 512     }
 513
 514     public static OrderedByStatement createOrderedBy(final Ordering argument) {
 515         return new EmptyOrderedByStatement(argument);
 516     }
 517
 518     public static OrderedByStatement createOrderedBy(final Ordering argument,
 519             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 520         return substatements.isEmpty() ? createOrderedBy(argument)
 521             : new RegularOrderedByStatement(argument, substatements);
 522     }
 523
 524     public static PathStatement createPath(final PathExpression argument) {
 525         return new EmptyPathStatement(argument);
 526     }
 527
 528     public static PathStatement createPath(final PathExpression argument,
 529             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 530         return substatements.isEmpty() ? createPath(argument) : new RegularPathStatement(argument, substatements);
 531     }
 532
 533     public static PatternStatement createPattern(final PatternExpression argument) {
 534         return new EmptyPatternStatement(argument);
 535     }
 536
 537     public static PatternStatement createPattern(final PatternExpression argument,
 538             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 539         return substatements.isEmpty() ? createPattern(argument)
 540             : new RegularPatternStatement(argument, substatements);
 541     }
 542
 543     public static PositionStatement createPosition(final Uint32 argument) {
 544         return new EmptyPositionStatement(argument);
 545     }
 546
 547     public static PositionStatement createPosition(final Uint32 argument,
 548             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 549         return substatements.isEmpty() ? createPosition(argument)
 550             : new RegularPositionStatement(argument, substatements);
 551     }
 552
 553     public static PrefixStatement createPrefix(final String argument) {
 554         return new EmptyPrefixStatement(argument);
 555     }
 556
 557     public static PrefixStatement createPrefix(final String argument,
 558             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 559         return substatements.isEmpty() ? createPrefix(argument) : new RegularPrefixStatement(argument, substatements);
 560     }
 561
 562     public static PresenceStatement createPresence(final String argument) {
 563         return new EmptyPresenceStatement(argument);
 564     }
 565
 566     public static PresenceStatement createPresence(final String argument,
 567             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 568         return substatements.isEmpty() ? createPresence(argument)
 569             : new RegularPresenceStatement(argument, substatements);
 570     }
 571
 572     public static ReferenceStatement createReference(final String argument) {
 573         return new EmptyReferenceStatement(argument);
 574     }
 575
 576     public static ReferenceStatement createReference(final String argument,
 577             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 578         return substatements.isEmpty() ? createReference(argument)
 579             : new RegularReferenceStatement(argument, substatements);
 580     }
 581
 582     public static RangeStatement createRange(final String rawArgument, final List<ValueRange> argument) {
 583         return new EmptyRangeStatement(rawArgument, argument);
 584     }
 585
 586     public static RangeStatement createRange(final String rawArgument, final List<ValueRange> argument,
 587             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 588         return substatements.isEmpty() ? createRange(rawArgument, argument)
 589             : new RegularRangeStatement(rawArgument, argument, substatements);
 590     }
 591
 592     public static RefineStatement createRefine(final String rawArgument, final Descendant argument) {
 593         return createRefine(rawArgument, argument, ImmutableList.of());
 594     }
 595
 596     public static RefineStatement createRefine(final String rawArgument, final Descendant argument,
 597             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 598         return new RefineStatementImpl(rawArgument, argument, substatements);
 599     }
 600
 601     public static RequireInstanceStatement createRequireInstance(final Boolean argument) {
 602         return new EmptyRequireInstanceStatement(argument);
 603     }
 604
 605     public static RequireInstanceStatement createRequireInstance(final Boolean argument,
 606             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 607         return substatements.isEmpty() ? createRequireInstance(argument)
 608             : new RegularRequireInstanceStatement(argument, substatements);
 609     }
 610
 611     public static RevisionStatement createRevision(final Revision argument) {
 612         return new EmptyRevisionStatement(argument);
 613     }
 614
 615     public static RevisionStatement createRevision(final Revision argument,
 616             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 617         return substatements.isEmpty() ? createRevision(argument)
 618             : new RegularRevisionStatement(argument, substatements);
 619     }
 620
 621     public static RevisionDateStatement createRevisionDate(final Revision argument) {
 622         return new EmptyRevisionDateStatement(argument);
 623     }
 624
 625     public static RevisionDateStatement createRevisionDate(final Revision argument,
 626             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 627         return substatements.isEmpty() ? createRevisionDate(argument)
 628             : new RegularRevisionDateStatement(argument, substatements);
 629     }
 630
 631     public static RpcStatement createRpc(final QName argument) {
 632         return new EmptyRpcStatement(argument);
 633     }
 634
 635     public static RpcStatement createRpc(final QName argument,
 636             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 637         return substatements.isEmpty() ? createRpc(argument) : new RegularRpcStatement(argument, substatements);
 638     }
 639
 640     public static StatusStatement createStatus(final Status argument) {
 641         return new EmptyStatusStatement(argument);
 642     }
 643
 644     public static StatusStatement createStatus(final Status argument,
 645             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 646         return substatements.isEmpty() ? createStatus(argument) : new RegularStatusStatement(argument, substatements);
 647     }
 648
 649     public static SubmoduleStatement createSubmodule(final String rawArgument, final UnqualifiedQName argument,
 650             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 651         return new SubmoduleStatementImpl(rawArgument, argument, substatements);
 652     }
 653
 654     public static TypeStatement createType(final String argument) {
 655         return new EmptyTypeStatement(argument);
 656     }
 657
 658     public static TypeStatement createType(final String argument,
 659             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 660         return substatements.isEmpty() ? createType(argument) : new RegularTypeStatement(argument, substatements);
 661     }
 662
 663     public static TypedefStatement createTypedef(final QName argument) {
 664         return new EmptyTypedefStatement(argument);
 665     }
 666
 667     public static TypedefStatement createTypedef(final QName argument,
 668             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 669         return substatements.isEmpty() ? createTypedef(argument) : new RegularTypedefStatement(argument, substatements);
 670     }
 671
 672     public static UniqueStatement createUnique(final String rawArgument, final Set<Descendant> argument) {
 673         return new EmptyUniqueStatement(rawArgument, argument);
 674     }
 675
 676     public static UniqueStatement createUnique(final String rawArgument, final Set<Descendant> argument,
 677             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 678         return substatements.isEmpty() ? createUnique(rawArgument, argument)
 679             : new RegularUniqueStatement(rawArgument, argument, substatements);
 680     }
 681
 682     public static UnitsStatement createUnits(final String argument) {
 683         return new EmptyUnitsStatement(argument);
 684     }
 685
 686     public static UnitsStatement createUnits(final String argument,
 687             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 688         return substatements.isEmpty() ? createUnits(argument) : new RegularUnitsStatement(argument, substatements);
 689     }
 690
 691     public static UsesStatement createUses(final String rawArgument, final QName argument) {
 692         return new EmptyUsesStatement(rawArgument, argument);
 693     }
 694
 695     public static UsesStatement createUses(final String rawArgument, final QName argument,
 696             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 697         return substatements.isEmpty() ? createUses(rawArgument, argument)
 698             : new RegularUsesStatement(rawArgument, argument, substatements);
 699     }
 700
 701     public static ValueStatement createValue(final Integer argument) {
 702         return new EmptyValueStatement(argument);
 703     }
 704
 705     public static ValueStatement createValue(final Integer argument,
 706             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 707         return substatements.isEmpty() ? createValue(argument) : new RegularValueStatement(argument, substatements);
 708     }
 709
 710     public static WhenStatement createWhen(final String rawArgument, final QualifiedBound argument) {
 711         return new EmptyWhenStatement(rawArgument, argument);
 712     }
 713
 714     public static WhenStatement createWhen(final String rawArgument, final QualifiedBound argument,
 715             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 716         return substatements.isEmpty() ? createWhen(rawArgument, argument)
 717             : new RegularWhenStatement(rawArgument, argument, substatements);
 718     }
 719
 720     public static YangVersionStatement createYangVersion(final YangVersion argument) {
 721         return new EmptyYangVersionStatement(argument);
 722     }
 723
 724     public static YangVersionStatement createYangVersion(final YangVersion argument,
 725             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 726         return substatements.isEmpty() ? createYangVersion(argument)
 727             : new RegularYangVersionStatement(argument, substatements);
 728     }
 729
 730     public static YinElementStatement createYinElement(final Boolean argument) {
 731         return new EmptyYinElementStatement(argument);
 732     }
 733
 734     public static YinElementStatement createYinElement(final Boolean argument,
 735             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 736         return substatements.isEmpty() ? createYinElement(argument)
 737             : new RegularYinElementStatement(argument, substatements);
 738     }
 739 }