+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createBinary(final Current<?, ?> ctx,
+ final BinaryTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final LengthRestrictedTypeBuilder<BinaryTypeDefinition> builder =
+ RestrictedTypes.newBinaryBuilder(baseType, typeEffectiveSchemaPath(ctx));
+
+ for (EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof LengthEffectiveStatement) {
+ final LengthEffectiveStatement length = (LengthEffectiveStatement)stmt;
+
+ try {
+ builder.setLengthConstraint(length, length.argument());
+ } catch (IllegalStateException e) {
+ throw new SourceException(ctx.sourceReference(), e, "Multiple length constraints encountered");
+ } catch (InvalidLengthConstraintException e) {
+ throw new SourceException(ctx.sourceReference(), e, "Invalid length constraint %s",
+ length.argument());
+ }
+ }
+ }
+
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createBits(final Current<?, ?> ctx,
+ final BitsTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.getSchemaPath());
+
+ final YangVersion yangVersion = ctx.yangVersion();
+ for (final EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof BitEffectiveStatement) {
+ SourceException.throwIf(yangVersion != YangVersion.VERSION_1_1, ctx.sourceReference(),
+ "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<Uint32> 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));
+ }
+ }
+
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createBoolean(final Current<?, ?> ctx,
+ final BooleanTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newBooleanBuilder(baseType,
+ typeEffectiveSchemaPath(ctx)));
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createDecimal(final Current<?, ?> ctx,
+ final DecimalTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> builder =
+ RestrictedTypes.newDecima64Builder(baseType, typeEffectiveSchemaPath(ctx));
+
+ for (EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof RangeEffectiveStatement) {
+ final RangeEffectiveStatement range = (RangeEffectiveStatement) stmt;
+ builder.setRangeConstraint(range, range.argument());
+ }
+ if (stmt instanceof FractionDigitsEffectiveStatement) {
+ final Integer digits = ((FractionDigitsEffectiveStatement)stmt).argument();
+ SourceException.throwIf(baseType.getFractionDigits() != digits, ctx.sourceReference(),
+ "Cannot override fraction-digits from base type %s to %s", baseType, digits);
+ }
+ }
+
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createEmpty(final Current<?, ?> ctx,
+ final EmptyTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newEmptyBuilder(baseType,
+ typeEffectiveSchemaPath(ctx)));
+ }
+
+ private static @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.getSchemaPath());
+
+ final YangVersion yangVersion = ctx.yangVersion();
+ for (final EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof EnumEffectiveStatement) {
+ SourceException.throwIf(yangVersion != YangVersion.VERSION_1_1, ctx.sourceReference(),
+ "Restricted enumeration type is allowed only in YANG 1.1 version.");
+
+ final EnumEffectiveStatement enumSubStmt = (EnumEffectiveStatement) stmt;
+ final Optional<Integer> 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));
+ }
+ }
+
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createIdentityref(final Current<?, ?> ctx,
+ final IdentityrefTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newIdentityrefBuilder(baseType,
+ typeEffectiveSchemaPath(ctx)));
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createInstanceIdentifier(
+ final Current<?, ?> ctx, final InstanceIdentifierTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(baseType,
+ typeEffectiveSchemaPath(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.sourceReference(), e, "Invalid range constraint: %s",
+ e.getOffendingRanges());
+ }
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createLeafref(final Current<?, ?> ctx,
+ final LeafrefTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> builder =
+ RestrictedTypes.newLeafrefBuilder(baseType, AbstractTypeStatementSupport.typeEffectiveSchemaPath(ctx));
+
+ for (final EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof RequireInstanceEffectiveStatement) {
+ builder.setRequireInstance(((RequireInstanceEffectiveStatement) stmt).argument());
+ }
+ }
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createString(final Current<?, ?> ctx,
+ final StringTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final StringTypeBuilder builder = RestrictedTypes.newStringBuilder(baseType,
+ AbstractTypeStatementSupport.typeEffectiveSchemaPath(ctx));
+
+ for (EffectiveStatement<?, ?> stmt : substatements) {
+ if (stmt instanceof LengthEffectiveStatement) {
+ final LengthEffectiveStatement length = (LengthEffectiveStatement)stmt;
+
+ try {
+ builder.setLengthConstraint(length, length.argument());
+ } catch (IllegalStateException e) {
+ throw new SourceException(ctx.sourceReference(), e, "Multiple length constraints encountered");
+ } catch (InvalidLengthConstraintException e) {
+ throw new SourceException(ctx.sourceReference(), e, "Invalid length constraint %s",
+ length.argument());
+ }
+ }
+ if (stmt instanceof PatternEffectiveStatement) {
+ builder.addPatternConstraint((PatternEffectiveStatement) stmt);
+ }
+ }
+
+ return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
+ }
+
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createUnion(final Current<?, ?> ctx,
+ final UnionTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newUnionBuilder(baseType,
+ typeEffectiveSchemaPath(ctx)));
+ }
+
+ private static Uint32 getBaseTypeBitPosition(final String bitName, final BitsTypeDefinition baseType,
+ final Current<?, ?> ctx) {
+ for (Bit baseTypeBit : baseType.getBits()) {
+ if (bitName.equals(baseTypeBit.getName())) {
+ return baseTypeBit.getPosition();
+ }
+ }
+
+ throw new SourceException(ctx.sourceReference(), "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 Current<?, ?> ctx) {
+ for (EnumPair baseTypeEnumPair : baseType.getValues()) {
+ if (enumName.equals(baseTypeEnumPair.getName())) {
+ return baseTypeEnumPair.getValue();
+ }
+ }
+
+ throw new SourceException(ctx.sourceReference(), "Enum '%s' is not a subset of its base enumeration type %s.",
+ enumName, baseType.getQName());
+ }