+ private @NonNull TypeEffectiveStatement<TypeStatement> createEnum(final Current<?, ?> ctx,
+ final EnumTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType,
+ ctx.argumentAsTypeQName());
+
+ for (final EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof EnumEffectiveStatement) {
+ builder.addEnum(addRestrictedEnum(ctx, baseType, (EnumEffectiveStatement) stmt));
+ }
+ }
+
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ }
+
+ abstract @NonNull EnumPair addRestrictedEnum(@NonNull EffectiveStmtCtx stmt, @NonNull EnumTypeDefinition base,
+ @NonNull EnumEffectiveStatement enumStmt);
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createIdentityref(final Current<QName, ?> ctx,
+ final IdentityrefTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newIdentityrefBuilder(baseType,
+ typeEffectiveQName(ctx)));
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createInstanceIdentifier(final Current<QName, ?> ctx,
+ final InstanceIdentifierTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(baseType,
+ typeEffectiveQName(ctx));
+
+ for (EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof RequireInstanceEffectiveStatement) {
+ builder.setRequireInstance(((RequireInstanceEffectiveStatement)stmt).argument());
+ }
+ }
+
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ }
+
+ private static <T extends RangeRestrictedTypeDefinition<T, N>, N extends Number & Comparable<N>>
+ @NonNull TypeEffectiveStatement<TypeStatement> createIntegral(final Current<?, ?> ctx,
+ final TypeStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final RangeRestrictedTypeBuilder<T, N> builder) {
+ for (EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof RangeEffectiveStatement) {
+ final RangeEffectiveStatement rangeStmt = (RangeEffectiveStatement)stmt;
+ builder.setRangeConstraint(rangeStmt, rangeStmt.argument());
+ }
+ }
+
+ try {
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ } catch (InvalidRangeConstraintException e) {
+ throw new SourceException(ctx, e, "Invalid range constraint: %s", e.getOffendingRanges());
+ }
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createLeafref(final Current<QName, ?> ctx,
+ final LeafrefTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> builder =
+ RestrictedTypes.newLeafrefBuilder(baseType, AbstractTypeStatementSupport.typeEffectiveQName(ctx));
+
+ for (final EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof RequireInstanceEffectiveStatement) {
+ builder.setRequireInstance(((RequireInstanceEffectiveStatement) stmt).argument());
+ }
+ }
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);