X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-rfc7950%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Frfc7950%2Fstmt%2Ftype%2FAbstractTypeStatementSupport.java;h=d4cfade4b74e139f04497fc032afab6e6e1f480b;hb=5db72610e7358baa1f5c9dd85abc9e93f3c8b020;hp=aab13f090704d610c752d456ab2bef6cad973c69;hpb=68e01edf2b36097d5b0968200394c0c6c12713dc;p=yangtools.git diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java index aab13f0907..d4cfade4b7 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java @@ -13,11 +13,8 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import java.math.BigDecimal; import java.util.Collection; -import java.util.Optional; import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.common.Uint32; -import org.opendaylight.yangtools.yang.common.YangVersion; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; @@ -34,7 +31,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit; @@ -50,7 +46,6 @@ import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition; -import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition; @@ -70,6 +65,8 @@ import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes; import org.opendaylight.yangtools.yang.model.util.type.StringTypeBuilder; import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace; +import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx; +import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException; import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder; import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction; @@ -193,7 +190,7 @@ abstract class AbstractTypeStatementSupport @Override public void prerequisiteFailed(final Collection> failed) { - InferenceException.throwIf(failed.contains(typePrereq), stmt.getStatementSourceReference(), + InferenceException.throwIf(failed.contains(typePrereq), stmt.sourceReference(), "Type [%s] was not found.", typeQName); } }); @@ -223,83 +220,81 @@ abstract class AbstractTypeStatementSupport @Override protected final TypeStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - return new RegularTypeStatement(ctx, substatements); + return new RegularTypeStatement(ctx.coerceRawStatementArgument(), substatements); } @Override protected final TypeStatement createEmptyDeclared(final StmtContext ctx) { final TypeStatement builtin; - return (builtin = BuiltinTypeStatement.lookup(ctx)) != null ? builtin : new EmptyTypeStatement(ctx); + return (builtin = BuiltinTypeStatement.lookup(ctx)) != null ? builtin + : new EmptyTypeStatement(ctx.coerceRawStatementArgument()); } @Override - protected final TypeEffectiveStatement createEffective( - final StmtContext> ctx, - final TypeStatement declared, final ImmutableList> substatements) { + protected EffectiveStatement createEffective(final Current stmt, + final ImmutableList> substatements) { // First look up the proper base type - final TypeEffectiveStatement typeStmt = resolveType(ctx); + final TypeEffectiveStatement typeStmt = resolveType(stmt); + if (substatements.isEmpty()) { + return typeStmt; + } + // Now instantiate the proper effective statement for that type final TypeDefinition baseType = typeStmt.getTypeDefinition(); + final TypeStatement declared = stmt.declared(); if (baseType instanceof BinaryTypeDefinition) { - return createBinary(ctx, (BinaryTypeDefinition) baseType, declared, substatements); + return createBinary(stmt, (BinaryTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof BitsTypeDefinition) { - return createBits(ctx, (BitsTypeDefinition) baseType, declared, substatements); + return createBits(stmt, (BitsTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof BooleanTypeDefinition) { - return createBoolean(ctx, (BooleanTypeDefinition) baseType, declared, substatements); + return createBoolean(stmt, (BooleanTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof DecimalTypeDefinition) { - return createDecimal(ctx, (DecimalTypeDefinition) baseType, declared, substatements); + return createDecimal(stmt, (DecimalTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof EmptyTypeDefinition) { - return createEmpty(ctx, (EmptyTypeDefinition) baseType, declared, substatements); + return createEmpty(stmt, (EmptyTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof EnumTypeDefinition) { - return createEnum(ctx, (EnumTypeDefinition) baseType, declared, substatements); + return createEnum(stmt, (EnumTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof IdentityrefTypeDefinition) { - return createIdentityref(ctx, (IdentityrefTypeDefinition) baseType, declared, substatements); + return createIdentityref(stmt, (IdentityrefTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof InstanceIdentifierTypeDefinition) { - return createInstanceIdentifier(ctx, (InstanceIdentifierTypeDefinition) baseType, declared, substatements); + return createInstanceIdentifier(stmt, (InstanceIdentifierTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof Int8TypeDefinition) { - return createIntegral(ctx, declared, substatements, - RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType, typeEffectiveSchemaPath(ctx))); + return createIntegral(stmt, declared, substatements, + RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); } else if (baseType instanceof Int16TypeDefinition) { - return createIntegral(ctx, declared, substatements, - RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType, typeEffectiveSchemaPath(ctx))); + return createIntegral(stmt, declared, substatements, + RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); } else if (baseType instanceof Int32TypeDefinition) { - return createIntegral(ctx, declared, substatements, - RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType, typeEffectiveSchemaPath(ctx))); + return createIntegral(stmt, declared, substatements, + RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); } else if (baseType instanceof Int64TypeDefinition) { - return createIntegral(ctx, declared, substatements, - RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType, typeEffectiveSchemaPath(ctx))); + return createIntegral(stmt, declared, substatements, + RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); } else if (baseType instanceof LeafrefTypeDefinition) { - return createLeafref(ctx, (LeafrefTypeDefinition) baseType, declared, substatements); + return createLeafref(stmt, (LeafrefTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof StringTypeDefinition) { - return createString(ctx, (StringTypeDefinition) baseType, declared, substatements); + return createString(stmt, (StringTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof Uint8TypeDefinition) { - return createIntegral(ctx, declared, substatements, - RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType, typeEffectiveSchemaPath(ctx))); + return createIntegral(stmt, declared, substatements, + RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); } else if (baseType instanceof Uint16TypeDefinition) { - return createIntegral(ctx, declared, substatements, - RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType, typeEffectiveSchemaPath(ctx))); + return createIntegral(stmt, declared, substatements, + RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); } else if (baseType instanceof Uint32TypeDefinition) { - return createIntegral(ctx, declared, substatements, - RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType, typeEffectiveSchemaPath(ctx))); + return createIntegral(stmt, declared, substatements, + RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); } else if (baseType instanceof Uint64TypeDefinition) { - return createIntegral(ctx, declared, substatements, - RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType, typeEffectiveSchemaPath(ctx))); + return createIntegral(stmt, declared, substatements, + RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); } else if (baseType instanceof UnionTypeDefinition) { - return createUnion(ctx, (UnionTypeDefinition) baseType, declared, substatements); + return createUnion(stmt, (UnionTypeDefinition) baseType, declared, substatements); } else { throw new IllegalStateException("Unhandled base type " + baseType); } } - @Override - protected final EffectiveStatement createEmptyEffective( - final StmtContext> ctx, - final TypeStatement declared) { - return resolveType(ctx); - } - - static final SchemaPath typeEffectiveSchemaPath(final StmtContext stmtCtx) { - final SchemaPath path = stmtCtx.getSchemaPath().get(); + static final SchemaPath typeEffectiveSchemaPath(final Current stmt) { + final SchemaPath path = stmt.getSchemaPath(); final SchemaPath parent = path.getParent(); final QName parentQName = parent.getLastComponent(); checkArgument(parentQName != null, "Path %s has an empty parent", path); @@ -315,8 +310,8 @@ abstract class AbstractTypeStatementSupport * @return Resolved type * @throws SourceException if the target type cannot be found */ - private static @NonNull TypeEffectiveStatement resolveType(final StmtContext ctx) { - final String argument = ctx.coerceStatementArgument(); + private static @NonNull TypeEffectiveStatement resolveType(final Current ctx) { + final String argument = ctx.getArgument(); switch (argument) { case BINARY: return BuiltinEffectiveStatement.BINARY; @@ -345,15 +340,15 @@ abstract class AbstractTypeStatementSupport case UINT64: return BuiltinEffectiveStatement.UINT64; default: - final QName qname = StmtContextUtils.parseNodeIdentifier(ctx, argument); - final StmtContext typedef = - SourceException.throwIfNull(ctx.getFromNamespace(TypeNamespace.class, qname), - ctx.getStatementSourceReference(), "Type '%s' not found", qname); + final QName qname = StmtContextUtils.parseNodeIdentifier(ctx.caerbannog(), argument); + final StmtContext typedef = SourceException.throwIfNull( + ctx.getFromNamespace(TypeNamespace.class, qname), ctx.sourceReference(), + "Type '%s' not found", qname); return typedef.buildEffective().asTypeEffectiveStatement(); } } - private static @NonNull TypeEffectiveStatement createBinary(final StmtContext ctx, + private static @NonNull TypeEffectiveStatement createBinary(final Current ctx, final BinaryTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final LengthRestrictedTypeBuilder builder = @@ -366,10 +361,9 @@ abstract class AbstractTypeStatementSupport try { builder.setLengthConstraint(length, length.argument()); } catch (IllegalStateException e) { - throw new SourceException(ctx.getStatementSourceReference(), e, - "Multiple length constraints encountered"); + throw new SourceException(ctx.sourceReference(), e, "Multiple length constraints encountered"); } catch (InvalidLengthConstraintException e) { - throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid length constraint %s", + throw new SourceException(ctx.sourceReference(), e, "Invalid length constraint %s", length.argument()); } } @@ -378,42 +372,31 @@ abstract class AbstractTypeStatementSupport return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createBits(final StmtContext ctx, + private @NonNull TypeEffectiveStatement createBits(final Current ctx, final BitsTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { - final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.getSchemaPath().get()); + final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.getSchemaPath()); - final YangVersion yangVersion = ctx.getRootVersion(); for (final EffectiveStatement stmt : substatements) { if (stmt instanceof BitEffectiveStatement) { - SourceException.throwIf(yangVersion != YangVersion.VERSION_1_1, ctx.getStatementSourceReference(), - "Restricted bits type is allowed only in YANG 1.1 version."); - final BitEffectiveStatement bitSubStmt = (BitEffectiveStatement) stmt; - - // FIXME: this looks like a duplicate of BitsSpecificationEffectiveStatement - final Optional declaredPosition = bitSubStmt.getDeclaredPosition(); - final Uint32 effectivePos; - if (declaredPosition.isEmpty()) { - effectivePos = getBaseTypeBitPosition(bitSubStmt.argument(), baseType, ctx); - } else { - effectivePos = declaredPosition.get(); - } - - builder.addBit(EffectiveTypeUtil.buildBit(bitSubStmt, effectivePos)); + builder.addBit(addRestrictedBit(ctx, baseType, (BitEffectiveStatement) stmt)); } } return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createBoolean(final StmtContext ctx, + abstract @NonNull Bit addRestrictedBit(@NonNull EffectiveStmtCtx stmt, @NonNull BitsTypeDefinition base, + @NonNull BitEffectiveStatement bit); + + private static @NonNull TypeEffectiveStatement createBoolean(final Current ctx, final BooleanTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newBooleanBuilder(baseType, typeEffectiveSchemaPath(ctx))); } - private static @NonNull TypeEffectiveStatement createDecimal(final StmtContext ctx, + private static @NonNull TypeEffectiveStatement createDecimal(final Current ctx, final DecimalTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final RangeRestrictedTypeBuilder builder = @@ -426,7 +409,7 @@ abstract class AbstractTypeStatementSupport } if (stmt instanceof FractionDigitsEffectiveStatement) { final Integer digits = ((FractionDigitsEffectiveStatement)stmt).argument(); - SourceException.throwIf(baseType.getFractionDigits() != digits, ctx.getStatementSourceReference(), + SourceException.throwIf(baseType.getFractionDigits() != digits, ctx.sourceReference(), "Cannot override fraction-digits from base type %s to %s", baseType, digits); } } @@ -434,43 +417,31 @@ abstract class AbstractTypeStatementSupport return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createEmpty(final StmtContext ctx, + private static @NonNull TypeEffectiveStatement createEmpty(final Current ctx, final EmptyTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newEmptyBuilder(baseType, typeEffectiveSchemaPath(ctx))); } - private static @NonNull TypeEffectiveStatement createEnum(final StmtContext ctx, + private @NonNull TypeEffectiveStatement createEnum(final Current ctx, final EnumTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { - final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType, - ctx.getSchemaPath().get()); + final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType, ctx.getSchemaPath()); - final YangVersion yangVersion = ctx.getRootVersion(); for (final EffectiveStatement stmt : substatements) { if (stmt instanceof EnumEffectiveStatement) { - SourceException.throwIf(yangVersion != YangVersion.VERSION_1_1, ctx.getStatementSourceReference(), - "Restricted enumeration type is allowed only in YANG 1.1 version."); - - final EnumEffectiveStatement enumSubStmt = (EnumEffectiveStatement) stmt; - final Optional declaredValue = - enumSubStmt.findFirstEffectiveSubstatementArgument(ValueEffectiveStatement.class); - final int effectiveValue; - if (declaredValue.isEmpty()) { - effectiveValue = getBaseTypeEnumValue(enumSubStmt.getDeclared().rawArgument(), baseType, ctx); - } else { - effectiveValue = declaredValue.orElseThrow(); - } - - builder.addEnum(EffectiveTypeUtil.buildEnumPair(enumSubStmt, effectiveValue)); + builder.addEnum(addRestrictedEnum(ctx, baseType, (EnumEffectiveStatement) stmt)); } } return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createIdentityref(final StmtContext ctx, + abstract @NonNull EnumPair addRestrictedEnum(@NonNull EffectiveStmtCtx stmt, @NonNull EnumTypeDefinition base, + @NonNull EnumEffectiveStatement enumStmt); + + private static @NonNull TypeEffectiveStatement createIdentityref(final Current ctx, final IdentityrefTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newIdentityrefBuilder(baseType, @@ -478,8 +449,8 @@ abstract class AbstractTypeStatementSupport } private static @NonNull TypeEffectiveStatement createInstanceIdentifier( - final StmtContext ctx, final InstanceIdentifierTypeDefinition baseType, - final TypeStatement declared, final ImmutableList> substatements) { + final Current ctx, final InstanceIdentifierTypeDefinition baseType, final TypeStatement declared, + final ImmutableList> substatements) { final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(baseType, typeEffectiveSchemaPath(ctx)); @@ -493,7 +464,7 @@ abstract class AbstractTypeStatementSupport } private static , N extends Number & Comparable> - @NonNull TypeEffectiveStatement createIntegral(final StmtContext ctx, + @NonNull TypeEffectiveStatement createIntegral(final Current ctx, final TypeStatement declared, final ImmutableList> substatements, final RangeRestrictedTypeBuilder builder) { for (EffectiveStatement stmt : substatements) { @@ -506,12 +477,11 @@ abstract class AbstractTypeStatementSupport try { return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } catch (InvalidRangeConstraintException e) { - throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid range constraint: %s", - e.getOffendingRanges()); + throw new SourceException(ctx.sourceReference(), e, "Invalid range constraint: %s", e.getOffendingRanges()); } } - private static @NonNull TypeEffectiveStatement createLeafref(final StmtContext ctx, + private static @NonNull TypeEffectiveStatement createLeafref(final Current ctx, final LeafrefTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final RequireInstanceRestrictedTypeBuilder builder = @@ -525,7 +495,7 @@ abstract class AbstractTypeStatementSupport return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createString(final StmtContext ctx, + private static @NonNull TypeEffectiveStatement createString(final Current ctx, final StringTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final StringTypeBuilder builder = RestrictedTypes.newStringBuilder(baseType, @@ -538,54 +508,24 @@ abstract class AbstractTypeStatementSupport try { builder.setLengthConstraint(length, length.argument()); } catch (IllegalStateException e) { - throw new SourceException(ctx.getStatementSourceReference(), e, - "Multiple length constraints encountered"); + throw new SourceException(ctx.sourceReference(), e, "Multiple length constraints encountered"); } catch (InvalidLengthConstraintException e) { - throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid length constraint %s", + throw new SourceException(ctx.sourceReference(), e, "Invalid length constraint %s", length.argument()); } } if (stmt instanceof PatternEffectiveStatement) { - final PatternConstraint pattern = ((PatternEffectiveStatement)stmt).argument(); - if (pattern != null) { - builder.addPatternConstraint(pattern); - } else { - LOG.debug("Ignoring empty pattern statement {}", stmt); - } + builder.addPatternConstraint((PatternEffectiveStatement) stmt); } } return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createUnion(final StmtContext ctx, + private static @NonNull TypeEffectiveStatement createUnion(final Current ctx, final UnionTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newUnionBuilder(baseType, typeEffectiveSchemaPath(ctx))); } - - private static Uint32 getBaseTypeBitPosition(final String bitName, final BitsTypeDefinition baseType, - final StmtContext ctx) { - for (Bit baseTypeBit : baseType.getBits()) { - if (bitName.equals(baseTypeBit.getName())) { - return baseTypeBit.getPosition(); - } - } - - throw new SourceException(ctx.getStatementSourceReference(), - "Bit '%s' is not a subset of its base bits type %s.", bitName, baseType.getQName()); - } - - private static int getBaseTypeEnumValue(final String enumName, final EnumTypeDefinition baseType, - final StmtContext ctx) { - for (EnumPair baseTypeEnumPair : baseType.getValues()) { - if (enumName.equals(baseTypeEnumPair.getName())) { - return baseTypeEnumPair.getValue(); - } - } - - throw new SourceException(ctx.getStatementSourceReference(), - "Enum '%s' is not a subset of its base enumeration type %s.", enumName, baseType.getQName()); - } } \ No newline at end of file