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