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