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 org.eclipse.jdt.annotation.NonNullByDefault;
  13 import org.opendaylight.yangtools.yang.common.QName;
  14 import org.opendaylight.yangtools.yang.model.api.DeviateKind;
  15 import org.opendaylight.yangtools.yang.model.api.Status;
  16 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  17 import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
  18 import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
  19 import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
  20 import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
  21 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
  22 import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
  23 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
  24 import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
  25 import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
  26 import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
  27 import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
  28 import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
  29 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
  30 import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
  31 import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
  32 import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
  33 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
  34 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
  35 import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
  36 import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
  37 import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
  38 import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
  39 import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
  40 import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureExpr;
  41 import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
  42 import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
  43 import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
  44 import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
  45 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
  46 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
  47 import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
  48
  49 /**
  50  * Static entry point to instantiating {@link DeclaredStatement} covered in the {@code RFC7950} metamodel.
  51  */
  52 @Beta
  53 @NonNullByDefault
  54 public final class DeclaredStatements {
  55     private DeclaredStatements() {
  56         // Hidden on purpose
  57     }
  58
  59     public static ActionStatement createAction(final QName argument) {
  60         return new EmptyActionStatement(argument);
  61     }
  62
  63     public static ActionStatement createAction(final QName argument,
  64             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
  65         return substatements.isEmpty() ? createAction(argument) : new RegularActionStatement(argument, substatements);
  66     }
  67
  68     public static AnydataStatement createAnydata(final QName argument) {
  69         return new EmptyAnydataStatement(argument);
  70     }
  71
  72     public static AnydataStatement createAnydata(final QName argument,
  73             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
  74         return substatements.isEmpty() ? createAnydata(argument) : new RegularAnydataStatement(argument, substatements);
  75     }
  76
  77     public static AnyxmlStatement createAnyxml(final QName argument) {
  78         return new EmptyAnyxmlStatement(argument);
  79     }
  80
  81     public static AnyxmlStatement createAnyxml(final QName argument,
  82             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
  83         return substatements.isEmpty() ? createAnyxml(argument) : new RegularAnyxmlStatement(argument, substatements);
  84     }
  85
  86     public static ArgumentStatement createArgument(final QName argument) {
  87         return new EmptyArgumentStatement(argument);
  88     }
  89
  90     public static ArgumentStatement createArgument(final QName argument,
  91             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
  92         return substatements.isEmpty() ? createArgument(argument)
  93             : new RegularArgumentStatement(argument, substatements);
  94     }
  95
  96     public static AugmentStatement createAugment(final String rawArgument, final SchemaNodeIdentifier argument) {
  97         return new EmptyAugmentStatement(rawArgument, argument);
  98     }
  99
 100     public static AugmentStatement createAugment(final String rawArgument, final SchemaNodeIdentifier argument,
 101             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 102         return substatements.isEmpty() ? createAugment(rawArgument, argument)
 103             : new RegularAugmentStatement(rawArgument, argument, substatements);
 104     }
 105
 106     public static BaseStatement createBase(final QName argument) {
 107         return new EmptyBaseStatement(argument);
 108     }
 109
 110     public static BaseStatement createBase(final QName argument,
 111             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 112         return substatements.isEmpty() ? createBase(argument) : new RegularBaseStatement(argument, substatements);
 113     }
 114
 115     public static BelongsToStatement createBelongsTo(final String argument) {
 116         return new EmptyBelongsToStatement(argument);
 117     }
 118
 119     public static BelongsToStatement createBelongsTo(final String argument,
 120             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 121         return substatements.isEmpty() ? createBelongsTo(argument)
 122             : new RegularBelongsToStatement(argument, substatements);
 123     }
 124
 125     public static BitStatement createBit(final String argument) {
 126         return new EmptyBitStatement(argument);
 127     }
 128
 129     public static BitStatement createBit(final String argument,
 130             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 131         return substatements.isEmpty() ? createBit(argument) : new RegularBitStatement(argument, substatements);
 132     }
 133
 134     public static ChoiceStatement createChoice(final QName argument) {
 135         return new EmptyChoiceStatement(argument);
 136     }
 137
 138     public static ChoiceStatement createChoice(final QName argument,
 139             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 140         return substatements.isEmpty() ? createChoice(argument) : new RegularChoiceStatement(argument, substatements);
 141     }
 142
 143     public static ConfigStatement createConfig(final Boolean argument) {
 144         return new EmptyConfigStatement(argument);
 145     }
 146
 147     public static ConfigStatement createConfig(final Boolean argument,
 148             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 149         return substatements.isEmpty() ? createConfig(argument) : new RegularConfigStatement(argument, substatements);
 150     }
 151
 152     public static ContainerStatement createContainer(final QName argument) {
 153         return new EmptyContainerStatement(argument);
 154     }
 155
 156     public static ContainerStatement createContainer(final QName argument,
 157             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 158         return substatements.isEmpty() ? createContainer(argument)
 159             : new RegularContainerStatement(argument, substatements);
 160     }
 161
 162     public static DefaultStatement createDefault(final String argument) {
 163         return new EmptyDefaultStatement(argument);
 164     }
 165
 166     public static DefaultStatement createDefault(final String argument,
 167             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 168         return substatements.isEmpty() ? createDefault(argument) : new RegularDefaultStatement(argument, substatements);
 169     }
 170
 171     public static DescriptionStatement createDescription(final String argument) {
 172         return new EmptyDescriptionStatement(argument);
 173     }
 174
 175     public static DescriptionStatement createDescription(final String argument,
 176             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 177         return substatements.isEmpty() ? createDescription(argument)
 178             : new RegularDescriptionStatement(argument, substatements);
 179     }
 180
 181     public static DeviateStatement createDeviate(final DeviateKind argument) {
 182         // This is exceedingly unlikely, just reuse the implementation
 183         return createDeviate(argument, ImmutableList.of());
 184     }
 185
 186     public static DeviateStatement createDeviate(final DeviateKind argument,
 187             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 188         return new DeviateStatementImpl(argument, substatements);
 189     }
 190
 191     public static DeviationStatement createDeviation(final String rawArgument, final Absolute argument) {
 192         // This does not make really sense
 193         return createDeviation(rawArgument, argument, ImmutableList.of());
 194     }
 195
 196     public static DeviationStatement createDeviation(final String rawArgument, final Absolute argument,
 197             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 198         return new DeviationStatementImpl(rawArgument, argument, substatements);
 199     }
 200
 201     // FIXME: what is the distinction between rawArgument and argument?
 202     public static EnumStatement createEnum(final String rawArgument, final String argument) {
 203         return new EmptyEnumStatement(rawArgument, argument);
 204     }
 205
 206     public static EnumStatement createEnum(final String rawArgument, final String argument,
 207             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 208         return substatements.isEmpty() ? createEnum(rawArgument, argument)
 209             : new RegularEnumStatement(rawArgument, argument, substatements);
 210     }
 211
 212     public static ErrorAppTagStatement createErrorAppTag(final String argument) {
 213         return new EmptyErrorAppTagStatement(argument);
 214     }
 215
 216     public static ErrorAppTagStatement createErrorAppTag(final String argument,
 217             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 218         return substatements.isEmpty() ? createErrorAppTag(argument)
 219             : new RegularErrorAppTagStatement(argument, substatements);
 220     }
 221
 222     public static ErrorMessageStatement createErrorMessage(final String argument) {
 223         return new EmptyErrorMessageStatement(argument);
 224     }
 225
 226     public static ErrorMessageStatement createErrorMessage(final String argument,
 227             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 228         return substatements.isEmpty() ? createErrorMessage(argument)
 229             : new RegularErrorMessageStatement(argument, substatements);
 230     }
 231
 232     public static ExtensionStatement createExtension(final QName argument) {
 233         return new EmptyExtensionStatement(argument);
 234     }
 235
 236     public static ExtensionStatement createExtension(final QName argument,
 237             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 238         return substatements.isEmpty() ? createExtension(argument)
 239             : new RegularExtensionStatement(argument, substatements);
 240     }
 241
 242     public static FeatureStatement createFeature(final QName argument) {
 243         return new EmptyFeatureStatement(argument);
 244     }
 245
 246     public static FeatureStatement createFeature(final QName argument,
 247             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 248         return substatements.isEmpty() ? createFeature(argument) : new RegularFeatureStatement(argument, substatements);
 249     }
 250
 251     public static FractionDigitsStatement createFractionDigits(final Integer argument) {
 252         return new EmptyFractionDigitsStatement(argument);
 253     }
 254
 255     public static FractionDigitsStatement createFractionDigits(final Integer argument,
 256             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 257         return substatements.isEmpty() ? createFractionDigits(argument)
 258             : new RegularFractionDigitsStatement(argument, substatements);
 259     }
 260
 261     public static GroupingStatement createGrouping(final QName argument) {
 262         return new EmptyGroupingStatement(argument);
 263     }
 264
 265     public static GroupingStatement createGrouping(final QName argument,
 266             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 267         return substatements.isEmpty() ? createGrouping(argument)
 268             : new RegularGroupingStatement(argument, substatements);
 269     }
 270
 271     public static IdentityStatement createIdentity(final QName argument) {
 272         return new EmptyIdentityStatement(argument);
 273     }
 274
 275     public static IdentityStatement createIdentity(final QName argument,
 276             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 277         return substatements.isEmpty() ? createIdentity(argument)
 278             : new RegularIdentityStatement(argument, substatements);
 279     }
 280
 281     public static IfFeatureStatement createIfFeature(final String rawArgument, final IfFeatureExpr argument) {
 282         return new EmptyIfFeatureStatement(rawArgument, argument);
 283     }
 284
 285     public static IfFeatureStatement createIfFeature(final String rawArgument, final IfFeatureExpr argument,
 286             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 287         return substatements.isEmpty() ? createIfFeature(rawArgument, argument)
 288             : new RegularIfFeatureStatement(rawArgument, argument, substatements);
 289     }
 290
 291     public static ImportStatement createImport(final String argument) {
 292         // This should never happen
 293         return createImport(argument, ImmutableList.of());
 294     }
 295
 296     public static ImportStatement createImport(final String argument,
 297             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 298         return new ImportStatementImpl(argument, substatements);
 299     }
 300
 301     public static IncludeStatement createInclude(final String rawArgument, final String argument) {
 302         return new EmptyIncludeStatement(rawArgument, argument);
 303     }
 304
 305     public static IncludeStatement createInclude(final String rawArgument, final String argument,
 306             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 307         return substatements.isEmpty() ? createInclude(rawArgument, argument)
 308             : new RegularIncludeStatement(rawArgument, argument, substatements);
 309     }
 310
 311     public static InputStatement createInput(final QName argument) {
 312         return new EmptyInputStatement(argument);
 313     }
 314
 315     public static InputStatement createInput(final QName argument,
 316             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 317         return substatements.isEmpty() ? createInput(argument) : new RegularInputStatement(argument, substatements);
 318     }
 319
 320     public static StatusStatement createStatus(final Status argument) {
 321         return new EmptyStatusStatement(argument);
 322     }
 323
 324     public static StatusStatement createStatus(final Status argument,
 325             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 326         return substatements.isEmpty() ? createStatus(argument) : new RegularStatusStatement(argument, substatements);
 327     }
 328 }