Remove SchemaPath from TypeDefinition implementations

[yangtools.git] / yang / yang-model-util / src / main / java / org / opendaylight / yangtools / yang / model / util / type / RestrictedTypes.java

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java
index 86a2dfaba32b04695ed10669fa9eb0558e517643..7cc226a5387e84ff1be7838365bcb07e0f3d2ad6 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/RestrictedTypes.java
@@ -11,6 +11,7 @@ import com.google.common.annotations.Beta;
 import java.math.BigDecimal;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.Uint16;
 import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.common.Uint64;
@@ -78,11 +79,11 @@ public final class RestrictedTypes {
     }
 
     public static @NonNull LengthRestrictedTypeBuilder<BinaryTypeDefinition> newBinaryBuilder(
-            final @NonNull BinaryTypeDefinition baseType, final @Nullable SchemaPath path) {
-        return new LengthRestrictedTypeBuilder<>(baseType, path) {
+            final @NonNull BinaryTypeDefinition baseType, final @NonNull QName qname) {
+        return new LengthRestrictedTypeBuilder<>(baseType, qname) {
             @Override
             BinaryTypeDefinition buildType(final @Nullable LengthConstraint constraint) {
-                return new RestrictedBinaryType(getBaseType(), getPath(), getUnknownSchemaNodes(), constraint);
+                return new RestrictedBinaryType(getBaseType(), getQName(), getUnknownSchemaNodes(), constraint);
             }
 
             @Override
@@ -96,167 +97,165 @@ public final class RestrictedTypes {
         };
     }
 
-    public static @NonNull BitsTypeBuilder newBitsBuilder(final BitsTypeDefinition baseType,
-            final SchemaPath path) {
-        return new BitsTypeBuilder(baseType, path);
+    public static @NonNull BitsTypeBuilder newBitsBuilder(final BitsTypeDefinition baseType, final QName qname) {
+        return new BitsTypeBuilder(baseType, qname);
     }
 
     public static @NonNull TypeBuilder<BooleanTypeDefinition> newBooleanBuilder(
-            final @NonNull BooleanTypeDefinition baseType, final @Nullable SchemaPath path) {
-        return new AbstractRestrictedTypeBuilder<>(baseType, path) {
+            final @NonNull BooleanTypeDefinition baseType, final @NonNull QName qname) {
+        return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
             @Override
             BooleanTypeDefinition buildType() {
-                return new RestrictedBooleanType(getBaseType(), getPath(), getUnknownSchemaNodes());
+                return new RestrictedBooleanType(getBaseType(), getQName(), getUnknownSchemaNodes());
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> newDecima64Builder(
-            final DecimalTypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+            final DecimalTypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
             DecimalTypeDefinition buildType(final RangeConstraint<BigDecimal> rangeConstraint) {
-                return new RestrictedDecimalType(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+                return new RestrictedDecimalType(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
     public static @NonNull TypeBuilder<EmptyTypeDefinition> newEmptyBuilder(final EmptyTypeDefinition baseType,
-            final SchemaPath path) {
-        return new AbstractRestrictedTypeBuilder<>(baseType, path) {
+            final QName qname) {
+        return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
             @Override
             EmptyTypeDefinition buildType() {
-                return new RestrictedEmptyType(getBaseType(), getPath(), getUnknownSchemaNodes());
+                return new RestrictedEmptyType(getBaseType(), getQName(), getUnknownSchemaNodes());
             }
         };
     }
 
     public static @NonNull EnumerationTypeBuilder newEnumerationBuilder(final EnumTypeDefinition baseType,
-            final SchemaPath path) {
-        return new EnumerationTypeBuilder(baseType, path);
+            final QName qname) {
+        return new EnumerationTypeBuilder(baseType, qname);
     }
 
     public static @NonNull TypeBuilder<IdentityrefTypeDefinition> newIdentityrefBuilder(
-            final IdentityrefTypeDefinition baseType, final SchemaPath path) {
-        return new AbstractRestrictedTypeBuilder<>(baseType, path) {
+            final IdentityrefTypeDefinition baseType, final QName qname) {
+        return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
             @Override
             IdentityrefTypeDefinition buildType() {
-                return new RestrictedIdentityrefType(getBaseType(), getPath(), getUnknownSchemaNodes());
+                return new RestrictedIdentityrefType(getBaseType(), getQName(), getUnknownSchemaNodes());
             }
         };
     }
 
     public static @NonNull InstanceIdentifierTypeBuilder newInstanceIdentifierBuilder(
-            final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
-        return new InstanceIdentifierTypeBuilder(baseType, path);
+            final InstanceIdentifierTypeDefinition baseType, final QName qname) {
+        return new InstanceIdentifierTypeBuilder(baseType, qname);
     }
 
     public static @NonNull RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> newLeafrefBuilder(
-            final LeafrefTypeDefinition baseType, final SchemaPath path) {
-        return new RequireInstanceRestrictedTypeBuilder<>(baseType, path) {
+            final LeafrefTypeDefinition baseType, final QName qname) {
+        return new RequireInstanceRestrictedTypeBuilder<>(baseType, qname) {
             @Override
             LeafrefTypeDefinition buildType() {
                 final LeafrefTypeDefinition base = getBaseType();
                 if (getRequireInstance() == base.requireInstance()) {
                     return base;
                 }
-                return new RestrictedLeafrefType(getBaseType(), getPath(), getUnknownSchemaNodes(),
+                return new RestrictedLeafrefType(getBaseType(), getQName(), getUnknownSchemaNodes(),
                         getRequireInstance());
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<Int8TypeDefinition, Byte> newInt8Builder(
-            final Int8TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+            final Int8TypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
             Int8TypeDefinition buildType(final RangeConstraint<Byte> rangeConstraint) {
-                return new RestrictedInt8Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+                return new RestrictedInt8Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<Int16TypeDefinition, Short> newInt16Builder(
-            final Int16TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+            final Int16TypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
             Int16TypeDefinition buildType(final RangeConstraint<Short> rangeConstraint) {
-                return new RestrictedInt16Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+                return new RestrictedInt16Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<Int32TypeDefinition, Integer> newInt32Builder(
-            final Int32TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+            final Int32TypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
             Int32TypeDefinition buildType(final RangeConstraint<Integer> rangeConstraint) {
-                return new RestrictedInt32Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+                return new RestrictedInt32Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<Int64TypeDefinition, Long> newInt64Builder(
-            final Int64TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+            final Int64TypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
             Int64TypeDefinition buildType(final RangeConstraint<Long> rangeConstraint) {
-                return new RestrictedInt64Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+                return new RestrictedInt64Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
-    public static @NonNull StringTypeBuilder newStringBuilder(final StringTypeDefinition baseType,
-            final SchemaPath path) {
-        return new StringTypeBuilder(baseType, path);
+    public static @NonNull StringTypeBuilder newStringBuilder(final StringTypeDefinition baseType, final QName qname) {
+        return new StringTypeBuilder(baseType, qname);
     }
 
     public static @NonNull TypeBuilder<UnionTypeDefinition> newUnionBuilder(final UnionTypeDefinition baseType,
-            final SchemaPath path) {
-        return new AbstractRestrictedTypeBuilder<>(baseType, path) {
+            final QName qname) {
+        return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
             @Override
             UnionTypeDefinition buildType() {
-                return new RestrictedUnionType(getBaseType(), getPath(), getUnknownSchemaNodes());
+                return new RestrictedUnionType(getBaseType(), getQName(), getUnknownSchemaNodes());
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<Uint8TypeDefinition, Uint8> newUint8Builder(
-            final Uint8TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Uint8TypeDefinition, Uint8>(baseType, path) {
+            final Uint8TypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
-            Uint8TypeDefinition buildType(final RangeConstraint<Uint8> rangeConstraint) {
-                return new RestrictedUint8Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+            Uint8TypeDefinition buildType(final RangeConstraint<@NonNull Uint8> rangeConstraint) {
+                return new RestrictedUint8Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<Uint16TypeDefinition, Uint16> newUint16Builder(
-            final Uint16TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Uint16TypeDefinition, Uint16>(baseType, path) {
+            final Uint16TypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
-            Uint16TypeDefinition buildType(final RangeConstraint<Uint16> rangeConstraint) {
-                return new RestrictedUint16Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+            Uint16TypeDefinition buildType(final RangeConstraint<@NonNull Uint16> rangeConstraint) {
+                return new RestrictedUint16Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<Uint32TypeDefinition, Uint32> newUint32Builder(
-            final Uint32TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Uint32TypeDefinition, Uint32>(baseType, path) {
+            final Uint32TypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
-            Uint32TypeDefinition buildType(final RangeConstraint<Uint32> rangeConstraint) {
-                return new RestrictedUint32Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+            Uint32TypeDefinition buildType(final RangeConstraint<@NonNull Uint32> rangeConstraint) {
+                return new RestrictedUint32Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }
 
     public static @NonNull RangeRestrictedTypeBuilder<Uint64TypeDefinition, Uint64> newUint64Builder(
-            final Uint64TypeDefinition baseType, final SchemaPath path) {
-        return new RangeRestrictedTypeBuilderWithBase<Uint64TypeDefinition, Uint64>(baseType, path) {
+            final Uint64TypeDefinition baseType, final QName qname) {
+        return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
             @Override
-            Uint64TypeDefinition buildType(final RangeConstraint<Uint64> rangeConstraint) {
-                return new RestrictedUint64Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+            Uint64TypeDefinition buildType(final RangeConstraint<@NonNull Uint64> rangeConstraint) {
+                return new RestrictedUint64Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
             }
         };
     }