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