super(qname, unknownSchemaNodes);
}
+ AbstractBaseType(final AbstractBaseType<T> original, final QName qname) {
+ super(original, qname);
+ }
+
@Override
public final T getBaseType() {
return null;
public final Status getStatus() {
return Status.CURRENT;
}
+
+ @Override
+ T bindTo(final QName newName) {
+ // Most implementations just return self
+ // FIXME: or do we want to assert?
+ return (T) this;
+ }
}
this.units = units;
}
+ AbstractDerivedType(final AbstractDerivedType<T> original, final QName qname) {
+ super(original, qname);
+ this.baseType = original.baseType;
+ this.status = original.status;
+ this.defaultValue = original.defaultValue;
+ this.description = original.description;
+ this.reference = original.reference;
+ this.units = original.units;
+ }
+
@Override
public final T getBaseType() {
return baseType instanceof AbstractRestrictedType ? baseType.getBaseType() : baseType;
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ AbstractLengthRestrictedDerivedType(final AbstractLengthRestrictedDerivedType<T> original, final QName qname) {
+ super(original, qname);
+ }
+
@Override
public final Optional<LengthConstraint> getLengthConstraint() {
return baseType().getLengthConstraint();
this.lengthConstraint = lengthConstraint;
}
+ AbstractLengthRestrictedType(final AbstractLengthRestrictedType<T> original, final QName qname) {
+ super(original, qname);
+ this.lengthConstraint = original.lengthConstraint;
+ }
+
@Override
public final Optional<LengthConstraint> getLengthConstraint() {
return Optional.ofNullable(lengthConstraint);
this.rangeConstraint = requireNonNull(rangeConstraint);
}
+ AbstractRangeRestrictedBaseType(final AbstractRangeRestrictedBaseType<T, N> original, final QName qname) {
+ super(original, qname);
+ this.rangeConstraint = original.rangeConstraint;
+ }
+
@Override
public final Optional<RangeConstraint<N>> getRangeConstraint() {
return Optional.of(rangeConstraint);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ AbstractRangeRestrictedDerivedType(final AbstractRangeRestrictedDerivedType<T, N> original, final QName qname) {
+ super(original, qname);
+ }
+
@Override
public final Optional<RangeConstraint<N>> getRangeConstraint() {
return baseType().getRangeConstraint();
this.rangeConstraint = rangeConstraint;
}
+ AbstractRangeRestrictedType(final AbstractRangeRestrictedType<T, N> original, final QName qname) {
+ super(original, qname);
+ this.rangeConstraint = original.rangeConstraint;
+ }
+
@Override
public final Optional<RangeConstraint<N>> getRangeConstraint() {
return Optional.ofNullable(rangeConstraint);
this.baseType = requireNonNull(baseType);
}
+ AbstractRestrictedType(final AbstractRestrictedType<T> original, final QName qname) {
+ super(original, qname);
+ this.baseType = original.baseType;
+ }
+
@Override
public final T getBaseType() {
return baseType;
this.unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodes);
}
+ AbstractTypeDefinition(final AbstractTypeDefinition<T> original, final QName qname) {
+ this.unknownSchemaNodes = original.unknownSchemaNodes;
+ this.qname = requireNonNull(qname);
+ }
+
@Override
public final QName getQName() {
return qname;
return unknownSchemaNodes;
}
+ /**
+ * Bind this type definition to a new {@link QName}. The resulting definition will be equivalent to this definition
+ * in all aspects except its path.
+ *
+ * @param newQName New {@link QName} to use
+ * @return Bound type definition
+ */
+ abstract @NonNull T bindTo(@NonNull QName newQName);
+
@Override
public abstract String toString();
this.bits = ImmutableList.copyOf(bits);
}
+ private BaseBitsType(final BaseBitsType original, final QName qname) {
+ super(original, qname);
+ this.bits = original.bits;
+ }
+
+ @Override
+ BaseBitsType bindTo(final QName newQName) {
+ return new BaseBitsType(this, newQName);
+ }
+
@Override
public Collection<? extends Bit> getBits() {
return bits;
this.fractionDigits = fractionDigits;
}
+ private BaseDecimalType(final BaseDecimalType original, final QName qname) {
+ super(original, qname);
+ this.fractionDigits = original.fractionDigits;
+ }
+
+ @Override
+ BaseDecimalType bindTo(final QName newQName) {
+ return new BaseDecimalType(this, newQName);
+ }
+
@Override
public int getFractionDigits() {
return fractionDigits;
this.values = ImmutableList.copyOf(values);
}
+ private BaseEnumerationType(final BaseEnumerationType original, final QName qname) {
+ super(original, qname);
+ this.values = original.values;
+ }
+
+ @Override
+ BaseEnumerationType bindTo(final QName newQName) {
+ return new BaseEnumerationType(this, newQName);
+ }
+
@Override
public List<EnumPair> getValues() {
return values;
this.identities = requireNonNull(identities);
}
+ private BaseIdentityrefType(final BaseIdentityrefType original, final QName qname) {
+ super(original, qname);
+ this.identities = original.identities;
+ }
+
+ @Override
+ BaseIdentityrefType bindTo(final QName newQName) {
+ return new BaseIdentityrefType(this, newQName);
+ }
+
@Override
public Set<? extends IdentitySchemaNode> getIdentities() {
return identities;
public String toString() {
return Int32TypeDefinition.toString(this);
}
-
}
this.requireInstance = requireInstance;
}
+ private BaseLeafrefType(final BaseLeafrefType original, final QName qname) {
+ super(original, qname);
+ this.pathStatement = original.pathStatement;
+ this.requireInstance = original.requireInstance;
+ }
+
+ @Override
+ BaseLeafrefType bindTo(final QName newQName) {
+ return new BaseLeafrefType(this, newQName);
+ }
+
@Override
public PathExpression getPathStatement() {
return pathStatement;
this.types = ImmutableList.copyOf(types);
}
+ private BaseUnionType(final BaseUnionType original, final QName qname) {
+ super(original, qname);
+ this.types = original.types;
+ }
+
+ @Override
+ BaseUnionType bindTo(final QName newQName) {
+ return new BaseUnionType(this, newQName);
+ }
+
@Override
public List<TypeDefinition<?>> getTypes() {
return types;
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ private DerivedBinaryType(final DerivedBinaryType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedBinaryType bindTo(final QName newQName) {
+ return new DerivedBinaryType(this, newQName);
+ }
+
@Override
public int hashCode() {
return BinaryTypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ private DerivedBitsType(final DerivedBitsType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedBitsType bindTo(final QName newQName) {
+ return new DerivedBitsType(this, newQName);
+ }
+
@Override
public Collection<? extends Bit> getBits() {
return baseType().getBits();
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ private DerivedBooleanType(final DerivedBooleanType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedBooleanType bindTo(final QName newQName) {
+ return new DerivedBooleanType(this, newQName);
+ }
+
@Override
public int hashCode() {
return BooleanTypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ private DerivedDecimalType(final DerivedDecimalType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedDecimalType bindTo(final QName newQName) {
+ return new DerivedDecimalType(this, newQName);
+ }
+
@Override
public int getFractionDigits() {
return baseType().getFractionDigits();
final class DerivedEmptyType extends AbstractDerivedType<EmptyTypeDefinition> implements EmptyTypeDefinition {
DerivedEmptyType(final EmptyTypeDefinition baseType, final QName qname, final Object defaultValue,
- final String description, final String reference, final Status status, final String units,
- final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ private DerivedEmptyType(final DerivedEmptyType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedEmptyType bindTo(final QName newQName) {
+ return new DerivedEmptyType(this, newQName);
+ }
+
@Override
public int hashCode() {
return EmptyTypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ private DerivedEnumerationType(final DerivedEnumerationType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedEnumerationType bindTo(final QName newQName) {
+ return new DerivedEnumerationType(this, newQName);
+ }
+
@Override
public List<EnumPair> getValues() {
return baseType().getValues();
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedIdentityrefType(final DerivedIdentityrefType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedIdentityrefType bindTo(final QName newQName) {
+ return new DerivedIdentityrefType(this, newQName);
+ }
+
@Override
public Set<? extends IdentitySchemaNode> getIdentities() {
return baseType().getIdentities();
this.requireInstance = requireInstance;
}
+ private DerivedInstanceIdentifierType(final DerivedInstanceIdentifierType original, final QName qname) {
+ super(original, qname);
+ this.requireInstance = original.requireInstance;
+ }
+
+ @Override
+ DerivedInstanceIdentifierType bindTo(final QName newQName) {
+ return new DerivedInstanceIdentifierType(this, newQName);
+ }
+
@Override
public boolean requireInstance() {
return requireInstance;
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedInt16Type(final DerivedInt16Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedInt16Type bindTo(final QName newQName) {
+ return new DerivedInt16Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Int16TypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedInt32Type(final DerivedInt32Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedInt32Type bindTo(final QName newQName) {
+ return new DerivedInt32Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Int32TypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedInt64Type(final DerivedInt64Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedInt64Type bindTo(final QName newQName) {
+ return new DerivedInt64Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Int64TypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedInt8Type(final DerivedInt8Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedInt8Type bindTo(final QName newQName) {
+ return new DerivedInt8Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Int8TypeDefinition.hashCode(this);
final class DerivedLeafrefType extends AbstractDerivedType<LeafrefTypeDefinition> implements LeafrefTypeDefinition {
DerivedLeafrefType(final LeafrefTypeDefinition baseType, final QName qname, final Object defaultValue,
- final String description, final String reference, final Status status, final String units,
- final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedLeafrefType(final DerivedLeafrefType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedLeafrefType bindTo(final QName newQName) {
+ return new DerivedLeafrefType(this, newQName);
+ }
+
@Override
public PathExpression getPathStatement() {
return baseType().getPathStatement();
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedStringType(final DerivedStringType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedStringType bindTo(final QName newQName) {
+ return new DerivedStringType(this, newQName);
+ }
+
@Override
public List<PatternConstraint> getPatternConstraints() {
return baseType().getPatternConstraints();
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedUint16Type(final DerivedUint16Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedUint16Type bindTo(final QName newQName) {
+ return new DerivedUint16Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Uint16TypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedUint32Type(final DerivedUint32Type original, final QName newQName) {
+ super(original, newQName);
+ }
+
+ @Override
+ DerivedUint32Type bindTo(final QName newQName) {
+ return new DerivedUint32Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Uint32TypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedUint64Type(final DerivedUint64Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedUint64Type bindTo(final QName newQName) {
+ return new DerivedUint64Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Uint64TypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedUint8Type(final DerivedUint8Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedUint8Type bindTo(final QName newQName) {
+ return new DerivedUint8Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Uint8TypeDefinition.hashCode(this);
super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ private DerivedUnionType(final DerivedUnionType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ DerivedUnionType bindTo(final QName newQName) {
+ return new DerivedUnionType(this, newQName);
+ }
+
@Override
public List<TypeDefinition<?>> getTypes() {
return baseType().getTypes();
super(baseType, qname, unknownSchemaNodes, lengthConstraint);
}
+ private RestrictedBinaryType(final RestrictedBinaryType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedBinaryType bindTo(final QName newQName) {
+ return new RestrictedBinaryType(this, newQName);
+ }
+
@Override
public int hashCode() {
return BinaryTypeDefinition.hashCode(this);
this.bits = ImmutableList.copyOf(bits);
}
+ private RestrictedBitsType(final RestrictedBitsType original, final QName qname) {
+ super(original, qname);
+ this.bits = original.bits;
+ }
+
+ @Override
+ RestrictedBitsType bindTo(final QName newQName) {
+ return new RestrictedBitsType(this, newQName);
+ }
+
@Override
public Collection<? extends Bit> getBits() {
return bits;
super(baseType, qname, unknownSchemaNodes);
}
+ private RestrictedBooleanType(final RestrictedBooleanType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedBooleanType bindTo(final QName newQName) {
+ return new RestrictedBooleanType(this, newQName);
+ }
+
@Override
public int hashCode() {
return BooleanTypeDefinition.hashCode(this);
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedDecimalType(final RestrictedDecimalType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedDecimalType bindTo(final QName newQName) {
+ return new RestrictedDecimalType(this, newQName);
+ }
+
@Override
public int getFractionDigits() {
return getBaseType().getFractionDigits();
super(baseType, qname, unknownSchemaNodes);
}
+ private RestrictedEmptyType(final RestrictedEmptyType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedEmptyType bindTo(final QName newQName) {
+ return new RestrictedEmptyType(this, newQName);
+ }
+
@Override
public int hashCode() {
return EmptyTypeDefinition.hashCode(this);
this.values = ImmutableList.copyOf(values);
}
+ private RestrictedEnumerationType(final RestrictedEnumerationType original, final QName qname) {
+ super(original, qname);
+ this.values = original.values;
+ }
+
+ @Override
+ RestrictedEnumerationType bindTo(final QName newQName) {
+ return new RestrictedEnumerationType(this, newQName);
+ }
+
@Override
public List<EnumPair> getValues() {
return values;
super(baseType, qname, unknownSchemaNodes);
}
+ private RestrictedIdentityrefType(final RestrictedIdentityrefType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedIdentityrefType bindTo(final QName newQName) {
+ return new RestrictedIdentityrefType(this, newQName);
+ }
+
@Override
public Set<? extends IdentitySchemaNode> getIdentities() {
return getBaseType().getIdentities();
this.requireInstance = requireInstance;
}
+ private RestrictedInstanceIdentifierType(final RestrictedInstanceIdentifierType original, final QName qname) {
+ super(original, qname);
+ this.requireInstance = original.requireInstance;
+ }
+
+ @Override
+ RestrictedInstanceIdentifierType bindTo(final QName newQName) {
+ return new RestrictedInstanceIdentifierType(this, newQName);
+ }
+
@Override
public boolean requireInstance() {
return requireInstance;
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedInt16Type(final RestrictedInt16Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedInt16Type bindTo(final QName newQName) {
+ return new RestrictedInt16Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Int16TypeDefinition.hashCode(this);
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedInt32Type(final RestrictedInt32Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedInt32Type bindTo(final QName newQName) {
+ return new RestrictedInt32Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Int32TypeDefinition.hashCode(this);
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedInt64Type(final RestrictedInt64Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedInt64Type bindTo(final QName newQName) {
+ return new RestrictedInt64Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Int64TypeDefinition.hashCode(this);
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedInt8Type(final RestrictedInt8Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedInt8Type bindTo(final QName newQName) {
+ return new RestrictedInt8Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Int8TypeDefinition.hashCode(this);
this.requireInstance = requireInstance;
}
+ private RestrictedLeafrefType(final RestrictedLeafrefType original, final QName qname) {
+ super(original, qname);
+ this.requireInstance = original.requireInstance;
+ }
+
+ @Override
+ RestrictedLeafrefType bindTo(final QName newQName) {
+ return new RestrictedLeafrefType(this, newQName);
+ }
+
@Override
public PathExpression getPathStatement() {
return getBaseType().getPathStatement();
this.patternConstraints = ImmutableList.copyOf(patternConstraints);
}
+ private RestrictedStringType(final RestrictedStringType original, final QName qname) {
+ super(original, qname);
+ this.patternConstraints = original.patternConstraints;
+ }
+
+ @Override
+ RestrictedStringType bindTo(final QName newQName) {
+ return new RestrictedStringType(this, newQName);
+ }
+
@Override
public List<PatternConstraint> getPatternConstraints() {
return patternConstraints;
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedUint16Type(final RestrictedUint16Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedUint16Type bindTo(final QName newQName) {
+ return new RestrictedUint16Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Uint16TypeDefinition.hashCode(this);
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedUint32Type(final RestrictedUint32Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedUint32Type bindTo(final QName newQName) {
+ return new RestrictedUint32Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Uint32TypeDefinition.hashCode(this);
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedUint64Type(final RestrictedUint64Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedUint64Type bindTo(final QName newQName) {
+ return new RestrictedUint64Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Uint64TypeDefinition.hashCode(this);
super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
+ private RestrictedUint8Type(final RestrictedUint8Type original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedUint8Type bindTo(final QName newQName) {
+ return new RestrictedUint8Type(this, newQName);
+ }
+
@Override
public int hashCode() {
return Uint8TypeDefinition.hashCode(this);
super(baseType, qname, unknownSchemaNodes);
}
+ private RestrictedUnionType(final RestrictedUnionType original, final QName qname) {
+ super(original, qname);
+ }
+
+ @Override
+ RestrictedUnionType bindTo(final QName newQName) {
+ return new RestrictedUnionType(this, newQName);
+ }
+
@Override
public List<TypeDefinition<?>> getTypes() {
return getBaseType().getTypes();
*/
package org.opendaylight.yangtools.yang.model.util.type;
+import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
this.baseType = baseType;
}
+ /**
+ * Create a copy of specified {@link TypeDefinition} with specified {@link QName}.
+ *
+ * @param <T> Type definition type
+ * @param type Original type definition
+ * @param qname QName for the copy
+ * @return A copy of type definition
+ * @throws NullPointerException if any argument is null
+ * @throws IllegalArgumentException if {@code type} is not a recognised implementation
+ */
+ public static <T extends TypeDefinition<?>> @NonNull T copyTypeDefinition(final T type, final QName qname) {
+ if (qname.equals(type.getQName())) {
+ return type;
+ }
+ checkArgument(type instanceof AbstractTypeDefinition, "Unsupported type %s", type);
+ return (T) ((AbstractTypeDefinition<?>) type).bindTo(requireNonNull(qname));
+ }
+
final T getBaseType() {
return baseType;
}
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.type.ConcreteTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.ConcreteTypes;
+import org.opendaylight.yangtools.yang.model.util.type.TypeBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataSchemaNodeMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.MustConstraintMixin;
this.substatements = original.substatements;
this.path = path;
this.flags = flags;
- // TODO: lazy instantiation?
- this.type = buildType();
+ this.type = TypeBuilder.copyTypeDefinition(original.type, getQName());
}
@Override
Code Review / yangtools.git / commitdiff