model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.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.ri.stmt;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11
  12 import com.google.common.annotations.Beta;
  13 import com.google.common.collect.ImmutableList;
  14 import com.google.common.collect.ImmutableSet;
  15 import java.util.Set;
  16 import org.eclipse.jdt.annotation.NonNullByDefault;
  17 import org.eclipse.jdt.annotation.Nullable;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.common.QNameModule;
  20 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
  21 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
  22 import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
  23 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
  24 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  25 import org.opendaylight.yangtools.yang.model.api.stmt.ActionEffectiveStatement;
  26 import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
  27 import org.opendaylight.yangtools.yang.model.api.stmt.AnydataEffectiveStatement;
  28 import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
  29 import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlEffectiveStatement;
  30 import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
  31 import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentEffectiveStatement;
  32 import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
  33 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
  34 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
  35 import org.opendaylight.yangtools.yang.model.api.stmt.BaseEffectiveStatement;
  36 import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
  37 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToEffectiveStatement;
  38 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
  39 import org.opendaylight.yangtools.yang.model.api.stmt.BitEffectiveStatement;
  40 import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
  41 import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
  42 import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
  43 import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
  44 import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
  45 import org.opendaylight.yangtools.yang.model.api.stmt.ConfigEffectiveStatement;
  46 import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
  47 import org.opendaylight.yangtools.yang.model.api.stmt.ContactEffectiveStatement;
  48 import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
  49 import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
  50 import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
  51 import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement;
  52 import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
  53 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
  54 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
  55 import org.opendaylight.yangtools.yang.model.api.stmt.DeviateEffectiveStatement;
  56 import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
  57 import org.opendaylight.yangtools.yang.model.api.stmt.DeviationEffectiveStatement;
  58 import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
  59 import org.opendaylight.yangtools.yang.model.api.stmt.EnumEffectiveStatement;
  60 import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
  61 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
  62 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
  63 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
  64 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
  65 import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionEffectiveStatement;
  66 import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
  67 import org.opendaylight.yangtools.yang.model.api.stmt.FeatureEffectiveStatement;
  68 import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
  69 import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement;
  70 import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
  71 import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
  72 import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
  73 import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
  74 import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
  75 import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureEffectiveStatement;
  76 import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
  77 import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
  78 import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
  79 import org.opendaylight.yangtools.yang.model.api.stmt.IncludeEffectiveStatement;
  80 import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
  81 import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
  82 import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
  83 import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
  84 import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
  85 import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
  86 import org.opendaylight.yangtools.yang.model.api.stmt.LeafListEffectiveStatement;
  87 import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
  88 import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement;
  89 import org.opendaylight.yangtools.yang.model.api.stmt.LengthEffectiveStatement;
  90 import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
  91 import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
  92 import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
  93 import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement;
  94 import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
  95 import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement;
  96 import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
  97 import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement;
  98 import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
  99 import org.opendaylight.yangtools.yang.model.api.stmt.ModifierEffectiveStatement;
 100 import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
 101 import org.opendaylight.yangtools.yang.model.api.stmt.MustEffectiveStatement;
 102 import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
 103 import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement;
 104 import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
 105 import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
 106 import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
 107 import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
 108 import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
 109 import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement;
 110 import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
 111 import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
 112 import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
 113 import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement;
 114 import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
 115 import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
 116 import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
 117 import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement;
 118 import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
 119 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement;
 120 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
 121 import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement;
 122 import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
 123 import org.opendaylight.yangtools.yang.model.api.stmt.RangeEffectiveStatement;
 124 import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
 125 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
 126 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
 127 import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement;
 128 import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
 129 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateEffectiveStatement;
 130 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
 131 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionEffectiveStatement;
 132 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
 133 import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
 134 import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
 135 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
 136 import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
 137 import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
 138 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
 139 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
 140 import org.opendaylight.yangtools.yang.model.api.stmt.UniqueEffectiveStatement;
 141 import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
 142 import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
 143 import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
 144 import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement;
 145 import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
 146 import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
 147 import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
 148 import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement;
 149 import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
 150 import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStatement;
 151 import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
 152 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
 153 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.decl.EmptyRequireInstanceStatement;
 154 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.decl.EmptyStatusStatement;
 155 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.decl.EmptyYangVersionStatement;
 156 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.AbstractChoiceEffectiveStatement;
 157 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.AbstractContainerEffectiveStatement;
 158 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.AbstractLeafEffectiveStatement;
 159 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.ActionEffectiveStatementImpl;
 160 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.AugmentEffectiveStatementImpl;
 161 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.DeclaredCaseEffectiveStatement;
 162 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.DeclaredInputEffectiveStatement;
 163 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.DeclaredOutputEffectiveStatement;
 164 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.DeviateEffectiveStatementImpl;
 165 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.DeviationEffectiveStatementImpl;
 166 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyAnydataEffectiveStatement;
 167 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyAnyxmlEffectiveStatement;
 168 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyArgumentEffectiveStatement;
 169 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyBaseEffectiveStatement;
 170 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyBelongsToEffectiveStatement;
 171 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyBitEffectiveStatement;
 172 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyChoiceEffectiveStatement;
 173 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyConfigEffectiveStatement;
 174 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyContactEffectiveStatement;
 175 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyContainerEffectiveStatement;
 176 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyDefaultEffectiveStatement;
 177 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyDescriptionEffectiveStatement;
 178 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyEnumEffectiveStatement;
 179 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyErrorAppTagEffectiveStatement;
 180 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyErrorMessageEffectiveStatement;
 181 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyFeatureEffectiveStatement;
 182 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyForeignKeyEffectiveStatement;
 183 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyFractionDigitsEffectiveStatement;
 184 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyGroupingEffectiveStatement;
 185 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyIdentityEffectiveStatement;
 186 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyIfFeatureEffectiveStatement;
 187 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyIncludeEffectiveStatement;
 188 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyLeafEffectiveStatement;
 189 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyLeafListEffectiveStatement;
 190 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyLengthEffectiveStatement;
 191 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyListEffectiveStatement;
 192 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyLocalKeyEffectiveStatement;
 193 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyMandatoryEffectiveStatement;
 194 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyMaxElementsEffectiveStatement;
 195 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyMinElementsEffectiveStatement;
 196 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyModifierEffectiveStatement;
 197 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyMustEffectiveStatement;
 198 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyNamespaceEffectiveStatement;
 199 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyOrderedByEffectiveStatement;
 200 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyOrganizationEffectiveStatement;
 201 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyPathEffectiveStatement;
 202 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyPatternEffectiveStatement;
 203 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyPositionEffectiveStatement;
 204 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyPrefixEffectiveStatement;
 205 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyPresenceEffectiveStatement;
 206 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyRangeEffectiveStatement;
 207 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyReferenceEffectiveStatement;
 208 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyRequireInstanceEffectiveStatement;
 209 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyRevisionDateEffectiveStatement;
 210 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyRevisionEffectiveStatement;
 211 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyStatusEffectiveStatement;
 212 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyUniqueEffectiveStatement;
 213 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyUnitsEffectiveStatement;
 214 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyValueEffectiveStatement;
 215 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyWhenEffectiveStatement;
 216 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyYangVersionEffectiveStatement;
 217 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyYinElementEffectiveStatement;
 218 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.ExtensionEffectiveStatementImpl;
 219 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.ImportEffectiveStatementImpl;
 220 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.NotificationEffectiveStatementImpl;
 221 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularAnydataEffectiveStatement;
 222 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularAnyxmlEffectiveStatement;
 223 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularArgumentEffectiveStatement;
 224 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularBaseEffectiveStatement;
 225 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularBelongsToEffectiveStatement;
 226 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularBitEffectiveStatement;
 227 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularChoiceEffectiveStatement;
 228 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularConfigEffectiveStatement;
 229 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularContactEffectiveStatement;
 230 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularContainerEffectiveStatement;
 231 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularDefaultEffectiveStatement;
 232 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularDescriptionEffectiveStatement;
 233 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularEnumEffectiveStatement;
 234 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularErrorAppTagEffectiveStatement;
 235 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularErrorMessageEffectiveStatement;
 236 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularFeatureEffectiveStatement;
 237 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularForeignKeyEffectiveStatement;
 238 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularFractionDigitsEffectiveStatement;
 239 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularGroupingEffectiveStatement;
 240 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularIdentityEffectiveStatement;
 241 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularIfFeatureEffectiveStatement;
 242 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularIncludeEffectiveStatement;
 243 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularLeafEffectiveStatement;
 244 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularLeafListEffectiveStatement;
 245 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularLengthEffectiveStatement;
 246 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularListEffectiveStatement;
 247 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularLocalKeyEffectiveStatement;
 248 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularMandatoryEffectiveStatement;
 249 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularMaxElementsEffectiveStatement;
 250 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularMinElementsEffectiveStatement;
 251 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularModifierEffectiveStatement;
 252 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularMustEffectiveStatement;
 253 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularNamespaceEffectiveStatement;
 254 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularOrderedByEffectiveStatement;
 255 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularOrganizationEffectiveStatement;
 256 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularPathEffectiveStatement;
 257 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularPatternEffectiveStatement;
 258 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularPositionEffectiveStatement;
 259 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularPrefixEffectiveStatement;
 260 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularPresenceEffectiveStatement;
 261 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularRangeEffectiveStatement;
 262 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularReferenceEffectiveStatement;
 263 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularRequireInstanceEffectiveStatement;
 264 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularRevisionDateEffectiveStatement;
 265 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularRevisionEffectiveStatement;
 266 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularStatusEffectiveStatement;
 267 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularUniqueEffectiveStatement;
 268 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularUnitsEffectiveStatement;
 269 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularValueEffectiveStatement;
 270 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularWhenEffectiveStatement;
 271 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularYangVersionEffectiveStatement;
 272 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularYinElementEffectiveStatement;
 273 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RpcEffectiveStatementImpl;
 274 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.SlimLeafListEffectiveStatement;
 275 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.TypedefEffectiveStatementImpl;
 276 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.UndeclaredCaseEffectiveStatement;
 277 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.UndeclaredInputEffectiveStatement;
 278 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.UndeclaredOutputEffectiveStatement;
 279 import org.opendaylight.yangtools.yang.model.spi.meta.SubstatementIndexingException;
 280
 281 /**
 282  * Static entry point to instantiating {@link EffectiveStatement} covered in the {@code RFC7950} metamodel.
 283  */
 284 @Beta
 285 @NonNullByDefault
 286 public final class EffectiveStatements {
 287     private EffectiveStatements() {
 288         // Hidden on purpose
 289     }
 290
 291     public static ActionEffectiveStatement copyAction(final ActionEffectiveStatement original, final QName argument,
 292             final int flags) {
 293         checkArgument(original instanceof ActionEffectiveStatementImpl, "Unsupported original %s", original);
 294         return new ActionEffectiveStatementImpl((ActionEffectiveStatementImpl) original, argument, flags);
 295     }
 296
 297     public static ActionEffectiveStatement createAction(final ActionStatement declared, final QName argument,
 298             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
 299                 throws SubstatementIndexingException {
 300         return new ActionEffectiveStatementImpl(declared, argument, flags, substatements);
 301     }
 302
 303     public static AnydataEffectiveStatement copyAnydata(final AnydataEffectiveStatement original, final QName argument,
 304             final int flags) {
 305         if (original instanceof RegularAnydataEffectiveStatement) {
 306             return new RegularAnydataEffectiveStatement((RegularAnydataEffectiveStatement) original, argument, flags);
 307         } else if (original instanceof EmptyAnydataEffectiveStatement) {
 308             return new EmptyAnydataEffectiveStatement((EmptyAnydataEffectiveStatement) original, argument, flags);
 309         } else {
 310             throw new IllegalArgumentException("Unsupported original " + original);
 311         }
 312     }
 313
 314     public static AnydataEffectiveStatement createAnydata(final AnydataStatement declared, final QName argument,
 315             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 316         return substatements.isEmpty() ? new EmptyAnydataEffectiveStatement(declared, argument, flags)
 317             : new RegularAnydataEffectiveStatement(declared, argument, flags, substatements);
 318     }
 319
 320     public static AnyxmlEffectiveStatement copyAnyxml(final AnyxmlEffectiveStatement original, final QName argument,
 321             final int flags) {
 322         if (original instanceof RegularAnyxmlEffectiveStatement) {
 323             return new RegularAnyxmlEffectiveStatement((RegularAnyxmlEffectiveStatement) original, argument, flags);
 324         } else if (original instanceof EmptyAnyxmlEffectiveStatement) {
 325             return new EmptyAnyxmlEffectiveStatement((EmptyAnyxmlEffectiveStatement) original, argument, flags);
 326         } else {
 327             throw new IllegalArgumentException("Unsupported original " + original);
 328         }
 329     }
 330
 331     public static AnyxmlEffectiveStatement createAnyxml(final AnyxmlStatement declared, final QName argument,
 332             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 333         return substatements.isEmpty() ? new EmptyAnyxmlEffectiveStatement(declared, argument, flags)
 334             : new RegularAnyxmlEffectiveStatement(declared, argument, flags, substatements);
 335     }
 336
 337     public static ArgumentEffectiveStatement createArgument(final ArgumentStatement declared,
 338             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 339         return substatements.isEmpty() ? new EmptyArgumentEffectiveStatement(declared)
 340             : new RegularArgumentEffectiveStatement(declared, substatements);
 341     }
 342
 343     public static AugmentEffectiveStatement createAugment(final AugmentStatement declared,
 344             final SchemaNodeIdentifier argument, final int flags, final QNameModule rootModuleQName,
 345             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
 346             final @Nullable AugmentationSchemaNode original) throws SubstatementIndexingException {
 347         return new AugmentEffectiveStatementImpl(declared, argument, flags, rootModuleQName, substatements, original);
 348     }
 349
 350     public static BaseEffectiveStatement createBase(final BaseStatement declared,
 351             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 352         return substatements.isEmpty() ? new EmptyBaseEffectiveStatement(declared)
 353             : new RegularBaseEffectiveStatement(declared, substatements);
 354     }
 355
 356     public static BelongsToEffectiveStatement createBelongsTo(final BelongsToStatement declared,
 357             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 358         return substatements.isEmpty() ? new EmptyBelongsToEffectiveStatement(declared)
 359             : new RegularBelongsToEffectiveStatement(declared, substatements);
 360     }
 361
 362     public static BitEffectiveStatement createBit(final BitStatement declared,
 363             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 364         return substatements.isEmpty() ? new EmptyBitEffectiveStatement(declared)
 365             : new RegularBitEffectiveStatement(declared, substatements);
 366     }
 367
 368     public static CaseEffectiveStatement copyCase(final CaseEffectiveStatement original, final QName argument,
 369             final int flags) {
 370         if (original instanceof DeclaredCaseEffectiveStatement) {
 371             return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original, argument, flags);
 372         } else if (original instanceof UndeclaredCaseEffectiveStatement) {
 373             return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original, argument, flags);
 374         } else {
 375             throw new IllegalArgumentException("Unsupported origin " + original);
 376         }
 377     }
 378
 379     public static CaseEffectiveStatement createCase(final QName argument, final int flags,
 380             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 381         return new UndeclaredCaseEffectiveStatement(substatements, argument, flags);
 382     }
 383
 384     public static CaseEffectiveStatement createCase(final CaseStatement declared, final QName argument,
 385             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 386         return new DeclaredCaseEffectiveStatement(declared, substatements, argument, flags);
 387     }
 388
 389     public static ChoiceEffectiveStatement copyChoice(final ChoiceEffectiveStatement original,
 390             final QName argument, final int flags) {
 391         checkArgument(original instanceof AbstractChoiceEffectiveStatement, "Unsupported original %s", original);
 392         final var orig = (AbstractChoiceEffectiveStatement) original;
 393         return argument.equals(orig.getDeclared().argument()) && orig.getDefaultCase().isEmpty()
 394             ? new EmptyChoiceEffectiveStatement(orig, flags)
 395                 : new RegularChoiceEffectiveStatement((AbstractChoiceEffectiveStatement) original, argument, flags);
 396     }
 397
 398     public static ChoiceEffectiveStatement createChoice(final ChoiceStatement declared, final QName argument,
 399             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
 400             final @Nullable CaseSchemaNode defaultCase) {
 401         return defaultCase == null && argument.equals(declared.argument())
 402             ? new EmptyChoiceEffectiveStatement(declared, substatements, flags)
 403                 : new RegularChoiceEffectiveStatement(declared, substatements, argument, flags, defaultCase);
 404     }
 405
 406     public static ConfigEffectiveStatement createConfig(final boolean argument) {
 407         return argument ? EmptyConfigEffectiveStatement.TRUE : EmptyConfigEffectiveStatement.FALSE;
 408     }
 409
 410     public static ConfigEffectiveStatement createConfig(final ConfigStatement declared) {
 411         return new EmptyConfigEffectiveStatement(declared);
 412     }
 413
 414     public static ConfigEffectiveStatement createConfig(final ConfigStatement declared,
 415             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 416         return substatements.isEmpty() ? createConfig(declared)
 417             : new RegularConfigEffectiveStatement(declared, substatements);
 418     }
 419
 420     public static ContactEffectiveStatement createContact(final ContactStatement declared) {
 421         return new EmptyContactEffectiveStatement(declared);
 422     }
 423
 424     public static ContactEffectiveStatement createContact(final ContactStatement declared,
 425             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 426         return substatements.isEmpty() ? createContact(declared)
 427             : new RegularContactEffectiveStatement(declared, substatements);
 428     }
 429
 430     public static ContainerEffectiveStatement copyContainer(final ContainerEffectiveStatement original,
 431             final QName argument, final int flags) {
 432         checkArgument(original instanceof AbstractContainerEffectiveStatement, "Unsupported original %s", original);
 433         final var orig = (AbstractContainerEffectiveStatement) original;
 434         return argument.equals(orig.getDeclared().argument()) ? new EmptyContainerEffectiveStatement(orig, flags)
 435             : new RegularContainerEffectiveStatement(orig, argument, flags);
 436     }
 437
 438     public static ContainerEffectiveStatement createContainer(final ContainerStatement declared, final QName argument,
 439             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 440         return argument.equals(declared.argument())
 441             ? new EmptyContainerEffectiveStatement(declared, substatements, flags)
 442                 : new RegularContainerEffectiveStatement(declared, substatements, argument, flags);
 443     }
 444
 445     public static DefaultEffectiveStatement createDefault(final DefaultStatement declared,
 446             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 447         return substatements.isEmpty() ? new EmptyDefaultEffectiveStatement(declared)
 448             : new RegularDefaultEffectiveStatement(declared, substatements);
 449     }
 450
 451     public static DescriptionEffectiveStatement createDescription(final DescriptionStatement declared,
 452             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 453         return substatements.isEmpty() ? new EmptyDescriptionEffectiveStatement(declared)
 454             : new RegularDescriptionEffectiveStatement(declared, substatements);
 455     }
 456
 457     public static DeviateEffectiveStatement createDeviate(final DeviateStatement declared,
 458             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 459         return new DeviateEffectiveStatementImpl(declared, substatements);
 460     }
 461
 462     public static DeviationEffectiveStatement createDeviation(final DeviationStatement declared,
 463             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 464         return new DeviationEffectiveStatementImpl(declared, substatements);
 465     }
 466
 467     public static EnumEffectiveStatement createEnum(final EnumStatement declared,
 468             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 469         return substatements.isEmpty() ? new EmptyEnumEffectiveStatement(declared)
 470             : new RegularEnumEffectiveStatement(declared, substatements);
 471     }
 472
 473     public static ErrorAppTagEffectiveStatement createErrorAppTag(final ErrorAppTagStatement declared,
 474             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 475         return substatements.isEmpty() ? new EmptyErrorAppTagEffectiveStatement(declared)
 476             : new RegularErrorAppTagEffectiveStatement(declared, substatements);
 477     }
 478
 479     public static ErrorMessageEffectiveStatement createErrorMessage(final ErrorMessageStatement declared,
 480             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 481         return substatements.isEmpty() ? new EmptyErrorMessageEffectiveStatement(declared)
 482             : new RegularErrorMessageEffectiveStatement(declared, substatements);
 483     }
 484
 485     public static ExtensionEffectiveStatement createExtension(final ExtensionStatement declared,
 486             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 487         return new ExtensionEffectiveStatementImpl(declared, substatements);
 488     }
 489
 490     public static FeatureEffectiveStatement createFeature(final FeatureStatement declared, final int flags,
 491             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 492         return substatements.isEmpty() ? new EmptyFeatureEffectiveStatement(declared, flags)
 493             : new RegularFeatureEffectiveStatement(declared, flags, substatements);
 494     }
 495
 496     public static FractionDigitsEffectiveStatement createFractionDigits(final FractionDigitsStatement declared) {
 497         return new EmptyFractionDigitsEffectiveStatement(declared);
 498     }
 499
 500     public static FractionDigitsEffectiveStatement createFractionDigits(final FractionDigitsStatement declared,
 501             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 502         return substatements.isEmpty() ? createFractionDigits(declared)
 503             : new RegularFractionDigitsEffectiveStatement(declared, substatements);
 504     }
 505
 506     public static GroupingEffectiveStatement createGrouping(final GroupingStatement declared,
 507             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
 508             final int flags) throws SubstatementIndexingException {
 509         return argument.equals(declared.argument())
 510             ? new EmptyGroupingEffectiveStatement(declared, substatements, flags)
 511                 : new RegularGroupingEffectiveStatement(declared, substatements, argument, flags);
 512     }
 513
 514     public static IfFeatureEffectiveStatement createIfFeature(final IfFeatureStatement declared,
 515             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 516         return substatements.isEmpty() ? new EmptyIfFeatureEffectiveStatement(declared)
 517             : new RegularIfFeatureEffectiveStatement(declared, substatements);
 518     }
 519
 520     public static IdentityEffectiveStatement createIdentity(final IdentityStatement declared) {
 521         return new EmptyIdentityEffectiveStatement(declared);
 522     }
 523
 524     public static IdentityEffectiveStatement createIdentity(final IdentityStatement declared, final int flags,
 525             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
 526             final ImmutableSet<IdentitySchemaNode> baseIdentities) {
 527         return new RegularIdentityEffectiveStatement(declared, flags, substatements, baseIdentities);
 528     }
 529
 530     public static ImportEffectiveStatement createImport(final ImportStatement declared,
 531             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
 532             final SourceIdentifier importedSource) {
 533         return new ImportEffectiveStatementImpl(declared, substatements, importedSource);
 534     }
 535
 536     public static IncludeEffectiveStatement createInclude(final IncludeStatement declared,
 537             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 538         return substatements.isEmpty() ? new EmptyIncludeEffectiveStatement(declared)
 539             : new RegularIncludeEffectiveStatement(declared, substatements);
 540     }
 541
 542     public static InputEffectiveStatement copyInput(final InputEffectiveStatement original, final QName argument,
 543             final int flags) {
 544         if (original instanceof DeclaredInputEffectiveStatement) {
 545             return new DeclaredInputEffectiveStatement((DeclaredInputEffectiveStatement) original, argument, flags);
 546         } else if (original instanceof UndeclaredInputEffectiveStatement) {
 547             return new UndeclaredInputEffectiveStatement((UndeclaredInputEffectiveStatement) original, argument, flags);
 548         } else {
 549             throw new IllegalArgumentException("Unsupported original " + original);
 550         }
 551     }
 552
 553     public static InputEffectiveStatement createInput(final QName argument, final int flags,
 554             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
 555             throws SubstatementIndexingException {
 556         return new UndeclaredInputEffectiveStatement(substatements, argument, flags);
 557     }
 558
 559     public static InputEffectiveStatement createInput(final InputStatement declared, final QName argument,
 560             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
 561                 throws SubstatementIndexingException {
 562         return new DeclaredInputEffectiveStatement(declared, substatements, argument, flags);
 563     }
 564
 565     public static KeyEffectiveStatement createKey(final KeyStatement declared, final Set<QName> argument,
 566             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 567         if (substatements.isEmpty()) {
 568             return argument.equals(declared.argument()) ? new EmptyLocalKeyEffectiveStatement(declared)
 569                 : new EmptyForeignKeyEffectiveStatement(declared, argument);
 570         }
 571         return argument.equals(declared.argument()) ? new RegularLocalKeyEffectiveStatement(declared, substatements)
 572             : new RegularForeignKeyEffectiveStatement(declared, argument, substatements);
 573     }
 574
 575     public static LeafEffectiveStatement copyLeaf(final LeafEffectiveStatement original, final QName argument,
 576             final int flags) {
 577         checkArgument(original instanceof AbstractLeafEffectiveStatement, "Unsupported original %s", original);
 578         final var orig = (AbstractLeafEffectiveStatement) original;
 579         return argument.equals(orig.getDeclared().argument()) ? new EmptyLeafEffectiveStatement(orig, flags)
 580             : new RegularLeafEffectiveStatement(orig, argument, flags);
 581     }
 582
 583     public static LeafEffectiveStatement createLeaf(final LeafStatement declared, final QName argument, final int flags,
 584             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
 585                 throws SubstatementIndexingException {
 586         return argument.equals(declared.argument()) ? new EmptyLeafEffectiveStatement(declared, flags, substatements)
 587             : new RegularLeafEffectiveStatement(declared, argument, flags, substatements);
 588     }
 589
 590     public static LeafListEffectiveStatement copyLeafList(final LeafListEffectiveStatement original,
 591             final QName argument, final int flags) {
 592         if (original instanceof RegularLeafListEffectiveStatement) {
 593             return new RegularLeafListEffectiveStatement((RegularLeafListEffectiveStatement) original, argument, flags);
 594         } else if (original instanceof SlimLeafListEffectiveStatement) {
 595             return new SlimLeafListEffectiveStatement((SlimLeafListEffectiveStatement) original, argument, flags);
 596         } else if (original instanceof EmptyLeafListEffectiveStatement) {
 597             // Promote to slim
 598             return new SlimLeafListEffectiveStatement((EmptyLeafListEffectiveStatement) original, argument, flags);
 599         } else {
 600             throw new IllegalArgumentException("Unsupported original " + original);
 601         }
 602     }
 603
 604     public static LeafListEffectiveStatement createLeafList(final LeafListStatement declared, final QName argument,
 605             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
 606             final ImmutableSet<String> defaultValues, final @Nullable ElementCountConstraint elementCountConstraint)
 607                 throws SubstatementIndexingException {
 608         if (defaultValues.isEmpty()) {
 609             return elementCountConstraint == null && argument.equals(declared.argument())
 610                 ? new EmptyLeafListEffectiveStatement(declared, flags, substatements)
 611                     : new SlimLeafListEffectiveStatement(declared, argument, flags, substatements,
 612                         elementCountConstraint);
 613         }
 614
 615         return new RegularLeafListEffectiveStatement(declared, argument, flags, substatements, defaultValues,
 616             elementCountConstraint);
 617     }
 618
 619     public static LengthEffectiveStatement createLength(final LengthStatement declared,
 620             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 621         return substatements.isEmpty() ? new EmptyLengthEffectiveStatement(declared)
 622             : new RegularLengthEffectiveStatement(declared, substatements);
 623     }
 624
 625     public static ListEffectiveStatement copyList(final ListEffectiveStatement original, final QName argument,
 626             final int flags) {
 627         if (original instanceof RegularListEffectiveStatement) {
 628             return new RegularListEffectiveStatement((RegularListEffectiveStatement) original, argument, flags);
 629         } else if (original instanceof EmptyListEffectiveStatement) {
 630             return new RegularListEffectiveStatement((EmptyListEffectiveStatement) original, argument, flags);
 631         } else {
 632             throw new IllegalArgumentException("Unsupported original " + original);
 633         }
 634     }
 635
 636     public static ListEffectiveStatement createList(final ListStatement declared, final QName argument,
 637             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
 638             final ImmutableList<QName> keyDefinition, final @Nullable ElementCountConstraint elementCountConstraint) {
 639         return elementCountConstraint == null && argument.equals(declared.argument())
 640             ? new EmptyListEffectiveStatement(declared, flags, substatements, keyDefinition)
 641                 : new RegularListEffectiveStatement(declared, argument, flags, substatements, keyDefinition,
 642                     elementCountConstraint);
 643     }
 644
 645     public static MandatoryEffectiveStatement createMandatory(final MandatoryStatement declared) {
 646         return new EmptyMandatoryEffectiveStatement(declared);
 647     }
 648
 649     public static MandatoryEffectiveStatement createMandatory(final MandatoryStatement declared,
 650             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 651         return substatements.isEmpty() ? createMandatory(declared)
 652             : new RegularMandatoryEffectiveStatement(declared, substatements);
 653     }
 654
 655     public static MaxElementsEffectiveStatement createMaxElements(final MaxElementsStatement declared,
 656             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 657         return substatements.isEmpty() ? new EmptyMaxElementsEffectiveStatement(declared)
 658             : new RegularMaxElementsEffectiveStatement(declared, substatements);
 659     }
 660
 661     public static MinElementsEffectiveStatement createMinElements(final MinElementsStatement declared) {
 662         return new EmptyMinElementsEffectiveStatement(declared);
 663     }
 664
 665     public static MinElementsEffectiveStatement createMinElements(final MinElementsStatement declared,
 666             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 667         return substatements.isEmpty() ? createMinElements(declared)
 668             : new RegularMinElementsEffectiveStatement(declared, substatements);
 669     }
 670
 671     public static ModifierEffectiveStatement createModifier(final ModifierStatement declared,
 672             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 673         return substatements.isEmpty() ? new EmptyModifierEffectiveStatement(declared)
 674             : new RegularModifierEffectiveStatement(declared, substatements);
 675     }
 676
 677     public static MustEffectiveStatement createMust(final MustStatement declared,
 678             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 679         return substatements.isEmpty() ? new EmptyMustEffectiveStatement(declared)
 680             : new RegularMustEffectiveStatement(declared, substatements);
 681     }
 682
 683     public static NamespaceEffectiveStatement createNamespace(final NamespaceStatement declared,
 684             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 685         return substatements.isEmpty() ? new EmptyNamespaceEffectiveStatement(declared)
 686             : new RegularNamespaceEffectiveStatement(declared, substatements);
 687     }
 688
 689     public static NotificationEffectiveStatement copyNotification(final NotificationEffectiveStatement original,
 690             final QName argument, final int flags) {
 691         checkArgument(original instanceof NotificationEffectiveStatementImpl, "Unsupported original %s", original);
 692         return new NotificationEffectiveStatementImpl((NotificationEffectiveStatementImpl) original, argument, flags);
 693     }
 694
 695     public static NotificationEffectiveStatement createNotification(final NotificationStatement declared,
 696             final QName argument, final int flags,
 697             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
 698                 throws SubstatementIndexingException {
 699         return new NotificationEffectiveStatementImpl(declared, substatements, argument, flags);
 700     }
 701
 702     public static OutputEffectiveStatement copyOutput(final OutputEffectiveStatement original, final QName argument,
 703             final int flags) {
 704         if (original instanceof DeclaredOutputEffectiveStatement) {
 705             return new DeclaredOutputEffectiveStatement((DeclaredOutputEffectiveStatement) original, argument, flags);
 706         } else if (original instanceof UndeclaredOutputEffectiveStatement) {
 707             return new UndeclaredOutputEffectiveStatement((UndeclaredOutputEffectiveStatement) original, argument,
 708                 flags);
 709         } else {
 710             throw new IllegalArgumentException("Unsupported original " + original);
 711         }
 712     }
 713
 714     public static OutputEffectiveStatement createOutput(final QName argument, final int flags,
 715             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
 716             throws SubstatementIndexingException {
 717         return new UndeclaredOutputEffectiveStatement(substatements, argument, flags);
 718     }
 719
 720     public static OutputEffectiveStatement createOutput(final OutputStatement declared, final QName argument,
 721             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements)
 722                 throws SubstatementIndexingException {
 723         return new DeclaredOutputEffectiveStatement(declared, substatements, argument, flags);
 724     }
 725
 726     public static OrderedByEffectiveStatement createOrderedBy(final OrderedByStatement declared) {
 727         return new EmptyOrderedByEffectiveStatement(declared);
 728     }
 729
 730     public static OrderedByEffectiveStatement createOrderedBy(final OrderedByStatement declared,
 731             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 732         return substatements.isEmpty() ? createOrderedBy(declared)
 733             : new RegularOrderedByEffectiveStatement(declared, substatements);
 734     }
 735
 736     public static OrganizationEffectiveStatement createOrganization(final OrganizationStatement declared) {
 737         return new EmptyOrganizationEffectiveStatement(declared);
 738     }
 739
 740     public static OrganizationEffectiveStatement createOrganization(final OrganizationStatement declared,
 741             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 742         return substatements.isEmpty() ? createOrganization(declared)
 743             : new RegularOrganizationEffectiveStatement(declared, substatements);
 744     }
 745
 746     public static PathEffectiveStatement createPath(final PathStatement declared,
 747             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 748         return substatements.isEmpty() ? new EmptyPathEffectiveStatement(declared)
 749             : new RegularPathEffectiveStatement(declared, substatements);
 750     }
 751
 752     public static PatternEffectiveStatement createPattern(final PatternStatement declared,
 753             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 754         return substatements.isEmpty() ? new EmptyPatternEffectiveStatement(declared)
 755             : new RegularPatternEffectiveStatement(declared, substatements);
 756     }
 757
 758     public static PositionEffectiveStatement createPosition(final PositionStatement declared) {
 759         return new EmptyPositionEffectiveStatement(declared);
 760     }
 761
 762     public static PositionEffectiveStatement createPosition(final PositionStatement declared,
 763             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 764         return substatements.isEmpty() ? createPosition(declared)
 765             : new RegularPositionEffectiveStatement(declared, substatements);
 766     }
 767
 768     public static PrefixEffectiveStatement createPrefix(final PrefixStatement declared,
 769             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 770         return substatements.isEmpty() ? new EmptyPrefixEffectiveStatement(declared)
 771             : new RegularPrefixEffectiveStatement(declared, substatements);
 772     }
 773
 774     public static PresenceEffectiveStatement createPresence(final PresenceStatement declared,
 775             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 776         return substatements.isEmpty() ? new EmptyPresenceEffectiveStatement(declared)
 777             : new RegularPresenceEffectiveStatement(declared, substatements);
 778     }
 779
 780     public static RangeEffectiveStatement createRange(final RangeStatement declared,
 781             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 782         return substatements.isEmpty() ? new EmptyRangeEffectiveStatement(declared)
 783             : new RegularRangeEffectiveStatement(declared, substatements);
 784     }
 785
 786     public static ReferenceEffectiveStatement createReference(final ReferenceStatement declared) {
 787         return new EmptyReferenceEffectiveStatement(declared);
 788     }
 789
 790     public static ReferenceEffectiveStatement createReference(final ReferenceStatement declared,
 791             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 792         return substatements.isEmpty() ? createReference(declared)
 793             : new RegularReferenceEffectiveStatement(declared, substatements);
 794     }
 795
 796     public static RevisionEffectiveStatement createRevision(final RevisionStatement declared,
 797             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 798         return substatements.isEmpty() ? new EmptyRevisionEffectiveStatement(declared)
 799             : new RegularRevisionEffectiveStatement(declared, substatements);
 800     }
 801
 802     public static RequireInstanceEffectiveStatement createRequireInstance(final boolean argument) {
 803         return argument ? EmptyRequireInstanceEffectiveStatement.TRUE : EmptyRequireInstanceEffectiveStatement.FALSE;
 804     }
 805
 806     public static RequireInstanceEffectiveStatement createRequireInstance(final RequireInstanceStatement declared) {
 807         if (EmptyRequireInstanceStatement.TRUE.equals(declared)) {
 808             return EmptyRequireInstanceEffectiveStatement.TRUE;
 809         } else if (EmptyRequireInstanceStatement.FALSE.equals(declared)) {
 810             return EmptyRequireInstanceEffectiveStatement.FALSE;
 811         } else {
 812             return new EmptyRequireInstanceEffectiveStatement(declared);
 813         }
 814     }
 815
 816     public static RequireInstanceEffectiveStatement createRequireInstance(final RequireInstanceStatement declared,
 817             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 818         return substatements.isEmpty() ? createRequireInstance(declared)
 819             : new RegularRequireInstanceEffectiveStatement(declared, substatements);
 820     }
 821
 822     public static RevisionDateEffectiveStatement createRevisionDate(final RevisionDateStatement declared,
 823             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 824         return substatements.isEmpty() ? new EmptyRevisionDateEffectiveStatement(declared)
 825             : new RegularRevisionDateEffectiveStatement(declared, substatements);
 826     }
 827
 828     public static RpcEffectiveStatement createRpc(final RpcStatement declared,
 829             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final QName argument,
 830             final int flags) throws SubstatementIndexingException {
 831         return new RpcEffectiveStatementImpl(declared, substatements, argument, flags);
 832     }
 833
 834     public static StatusEffectiveStatement createStatus(final StatusStatement declared) {
 835         // Aggressively reuse effective instances which are backed by the corresponding empty declared instance, as this
 836         // is the case unless there is a weird extension in use.
 837         if (EmptyStatusStatement.DEPRECATED.equals(declared)) {
 838             // Most likely to be seen (as current is the default)
 839             return EmptyStatusEffectiveStatement.DEPRECATED;
 840         } else if (EmptyStatusStatement.OBSOLETE.equals(declared)) {
 841             // less likely
 842             return EmptyStatusEffectiveStatement.OBSOLETE;
 843         } else if (EmptyStatusStatement.CURRENT.equals(declared)) {
 844             // ... okay, why is this there? :)
 845             return EmptyStatusEffectiveStatement.CURRENT;
 846         } else {
 847             return new EmptyStatusEffectiveStatement(declared);
 848         }
 849     }
 850
 851     public static StatusEffectiveStatement createStatus(final StatusStatement declared,
 852             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 853         return substatements.isEmpty() ? createStatus(declared)
 854             : new RegularStatusEffectiveStatement(declared, substatements);
 855     }
 856
 857     public static TypedefEffectiveStatement createTypedef(final TypedefStatement declared, final int flags,
 858             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 859         return new TypedefEffectiveStatementImpl(declared, flags, substatements);
 860     }
 861
 862     public static UnitsEffectiveStatement createUnits(final UnitsStatement declared,
 863             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 864         return substatements.isEmpty() ? new EmptyUnitsEffectiveStatement(declared)
 865             : new RegularUnitsEffectiveStatement(declared, substatements);
 866     }
 867
 868     public static UniqueEffectiveStatement createUnique(final UniqueStatement declared,
 869             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 870         return substatements.isEmpty() ? new EmptyUniqueEffectiveStatement(declared)
 871             : new RegularUniqueEffectiveStatement(declared, substatements);
 872     }
 873
 874     public static ValueEffectiveStatement createValue(final ValueStatement declared) {
 875         return new EmptyValueEffectiveStatement(declared);
 876     }
 877
 878     public static ValueEffectiveStatement createValue(final ValueStatement declared,
 879             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 880         return substatements.isEmpty() ? createValue(declared)
 881             : new RegularValueEffectiveStatement(declared, substatements);
 882     }
 883
 884     public static WhenEffectiveStatement createWhen(final WhenStatement declared,
 885             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 886         return substatements.isEmpty() ? new EmptyWhenEffectiveStatement(declared)
 887             : new RegularWhenEffectiveStatement(declared, substatements);
 888     }
 889
 890     public static YangVersionEffectiveStatement createYangVersion(final YangVersionStatement declared) {
 891         if (EmptyYangVersionStatement.VERSION_1.equals(declared)) {
 892             return EmptyYangVersionEffectiveStatement.VERSION_1;
 893         } else if (EmptyYangVersionStatement.VERSION_1_1.equals(declared)) {
 894             return EmptyYangVersionEffectiveStatement.VERSION_1_1;
 895         } else {
 896             return new EmptyYangVersionEffectiveStatement(declared);
 897         }
 898     }
 899
 900     public static YangVersionEffectiveStatement createYangVersion(final YangVersionStatement declared,
 901             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 902         return substatements.isEmpty() ? createYangVersion(declared)
 903             : new RegularYangVersionEffectiveStatement(declared, substatements);
 904     }
 905
 906     public static YinElementEffectiveStatement createYinElement(final YinElementStatement declared) {
 907         return new EmptyYinElementEffectiveStatement(declared);
 908     }
 909
 910     public static YinElementEffectiveStatement createYinElement(final YinElementStatement declared,
 911         final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 912         return substatements.isEmpty() ? createYinElement(declared)
 913             : new RegularYinElementEffectiveStatement(declared, substatements);
 914     }
 915 }