model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java

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