Remove SchemaPath from TypeDefinition implementations

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

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ConcreteTypes.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ConcreteTypes.java
index 039b2b9d715051d09dd778a67db1b95f6e290064..44bd9b49dc69cc3cf9c86864e9f74b8bcd15ae80 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ConcreteTypes.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ConcreteTypes.java
@@ -9,7 +9,7 @@ package org.opendaylight.yangtools.yang.model.util.type;
 
 import com.google.common.annotations.Beta;
 import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
@@ -41,254 +41,254 @@ public final class ConcreteTypes {
         // Hidden on purpose
     }
 
-    public static ConcreteTypeBuilder<?> concreteTypeBuilder(final TypeDefinition<?> baseType, final SchemaPath path) {
+    public static ConcreteTypeBuilder<?> concreteTypeBuilder(final TypeDefinition<?> baseType, final QName qname) {
         if (baseType instanceof BinaryTypeDefinition) {
-            return concreteBinaryBuilder((BinaryTypeDefinition) baseType, path);
+            return concreteBinaryBuilder((BinaryTypeDefinition) baseType, qname);
         } else if (baseType instanceof BitsTypeDefinition) {
-            return concreteBitsBuilder((BitsTypeDefinition) baseType, path);
+            return concreteBitsBuilder((BitsTypeDefinition) baseType, qname);
         } else if (baseType instanceof BooleanTypeDefinition) {
-            return concreteBooleanBuilder((BooleanTypeDefinition) baseType, path);
+            return concreteBooleanBuilder((BooleanTypeDefinition) baseType, qname);
         } else if (baseType instanceof DecimalTypeDefinition) {
-            return concreteDecimalBuilder((DecimalTypeDefinition) baseType, path);
+            return concreteDecimalBuilder((DecimalTypeDefinition) baseType, qname);
         } else if (baseType instanceof EmptyTypeDefinition) {
-            return concreteEmptyBuilder((EmptyTypeDefinition) baseType, path);
+            return concreteEmptyBuilder((EmptyTypeDefinition) baseType, qname);
         } else if (baseType instanceof EnumTypeDefinition) {
-            return concreteEnumerationBuilder((EnumTypeDefinition) baseType, path);
+            return concreteEnumerationBuilder((EnumTypeDefinition) baseType, qname);
         } else if (baseType instanceof IdentityrefTypeDefinition) {
-            return concreteIdentityrefBuilder((IdentityrefTypeDefinition) baseType, path);
+            return concreteIdentityrefBuilder((IdentityrefTypeDefinition) baseType, qname);
         } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
-            return concreteInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, path);
+            return concreteInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, qname);
         } else if (baseType instanceof Int8TypeDefinition) {
-            return concreteInt8Builder((Int8TypeDefinition) baseType, path);
+            return concreteInt8Builder((Int8TypeDefinition) baseType, qname);
         } else if (baseType instanceof Int16TypeDefinition) {
-            return concreteInt16Builder((Int16TypeDefinition) baseType, path);
+            return concreteInt16Builder((Int16TypeDefinition) baseType, qname);
         } else if (baseType instanceof Int32TypeDefinition) {
-            return concreteInt32Builder((Int32TypeDefinition) baseType, path);
+            return concreteInt32Builder((Int32TypeDefinition) baseType, qname);
         } else if (baseType instanceof Int64TypeDefinition) {
-            return concreteInt64Builder((Int64TypeDefinition) baseType, path);
+            return concreteInt64Builder((Int64TypeDefinition) baseType, qname);
         } else if (baseType instanceof LeafrefTypeDefinition) {
-            return concreteLeafrefBuilder((LeafrefTypeDefinition) baseType, path);
+            return concreteLeafrefBuilder((LeafrefTypeDefinition) baseType, qname);
         } else if (baseType instanceof StringTypeDefinition) {
-            return concreteStringBuilder((StringTypeDefinition) baseType, path);
+            return concreteStringBuilder((StringTypeDefinition) baseType, qname);
         } else if (baseType instanceof UnionTypeDefinition) {
-            return concreteUnionBuilder((UnionTypeDefinition) baseType, path);
+            return concreteUnionBuilder((UnionTypeDefinition) baseType, qname);
         } else if (baseType instanceof Uint8TypeDefinition) {
-            return concreteUint8Builder((Uint8TypeDefinition) baseType, path);
+            return concreteUint8Builder((Uint8TypeDefinition) baseType, qname);
         } else if (baseType instanceof Uint16TypeDefinition) {
-            return concreteUint16Builder((Uint16TypeDefinition) baseType, path);
+            return concreteUint16Builder((Uint16TypeDefinition) baseType, qname);
         } else if (baseType instanceof Uint32TypeDefinition) {
-            return concreteUint32Builder((Uint32TypeDefinition) baseType, path);
+            return concreteUint32Builder((Uint32TypeDefinition) baseType, qname);
         } else if (baseType instanceof Uint64TypeDefinition) {
-            return concreteUint64Builder((Uint64TypeDefinition) baseType, path);
+            return concreteUint64Builder((Uint64TypeDefinition) baseType, qname);
         } else {
             throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
         }
     }
 
     private static ConcreteTypeBuilder<BinaryTypeDefinition> concreteBinaryBuilder(
-            final BinaryTypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final BinaryTypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public BinaryTypeDefinition buildType() {
-                return new DerivedBinaryType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedBinaryType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<BitsTypeDefinition> concreteBitsBuilder(final BitsTypeDefinition baseType,
-            final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public BitsTypeDefinition buildType() {
-                return new DerivedBitsType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedBitsType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<BooleanTypeDefinition> concreteBooleanBuilder(
-            final BooleanTypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final BooleanTypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public BooleanTypeDefinition buildType() {
-                return new DerivedBooleanType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedBooleanType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<DecimalTypeDefinition> concreteDecimalBuilder(
-            final DecimalTypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final DecimalTypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public DecimalTypeDefinition buildType() {
-                return new DerivedDecimalType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedDecimalType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<EmptyTypeDefinition> concreteEmptyBuilder(final EmptyTypeDefinition baseType,
-            final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public EmptyTypeDefinition buildType() {
-                return new DerivedEmptyType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedEmptyType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<EnumTypeDefinition> concreteEnumerationBuilder(
-            final EnumTypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final EnumTypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public EnumTypeDefinition buildType() {
-                return new DerivedEnumerationType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedEnumerationType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<IdentityrefTypeDefinition> concreteIdentityrefBuilder(
-            final IdentityrefTypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final IdentityrefTypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public IdentityrefTypeDefinition buildType() {
-                return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedIdentityrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<InstanceIdentifierTypeDefinition> concreteInstanceIdentifierBuilder(
-            final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final InstanceIdentifierTypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public InstanceIdentifierTypeDefinition buildType() {
-                return new DerivedInstanceIdentifierType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedInstanceIdentifierType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes(), baseType.requireInstance());
             }
         };
     }
 
     private static ConcreteTypeBuilder<Int8TypeDefinition> concreteInt8Builder(
-            final Int8TypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final Int8TypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public Int8TypeDefinition buildType() {
-                return new DerivedInt8Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedInt8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<Int16TypeDefinition> concreteInt16Builder(
-            final Int16TypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final Int16TypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public Int16TypeDefinition buildType() {
-                return new DerivedInt16Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedInt16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<Int32TypeDefinition> concreteInt32Builder(
-            final Int32TypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final Int32TypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public Int32TypeDefinition buildType() {
-                return new DerivedInt32Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedInt32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<Int64TypeDefinition> concreteInt64Builder(
-            final Int64TypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final Int64TypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public Int64TypeDefinition buildType() {
-                return new DerivedInt64Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedInt64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<LeafrefTypeDefinition> concreteLeafrefBuilder(
-            final LeafrefTypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final LeafrefTypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public LeafrefTypeDefinition buildType() {
-                return new DerivedLeafrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedLeafrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<StringTypeDefinition> concreteStringBuilder(final StringTypeDefinition baseType,
-            final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public StringTypeDefinition buildType() {
-                return new DerivedStringType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedStringType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<UnionTypeDefinition> concreteUnionBuilder(final UnionTypeDefinition baseType,
-            final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public DerivedUnionType buildType() {
-                return new DerivedUnionType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedUnionType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<Uint8TypeDefinition> concreteUint8Builder(
-            final Uint8TypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final Uint8TypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public Uint8TypeDefinition buildType() {
-                return new DerivedUint8Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedUint8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<Uint16TypeDefinition> concreteUint16Builder(
-            final Uint16TypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final Uint16TypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public Uint16TypeDefinition buildType() {
-                return new DerivedUint16Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedUint16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<Uint32TypeDefinition> concreteUint32Builder(
-            final Uint32TypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final Uint32TypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public Uint32TypeDefinition buildType() {
-                return new DerivedUint32Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedUint32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };
     }
 
     private static ConcreteTypeBuilder<Uint64TypeDefinition> concreteUint64Builder(
-            final Uint64TypeDefinition baseType, final SchemaPath path) {
-        return new ConcreteTypeBuilder<>(baseType, path) {
+            final Uint64TypeDefinition baseType, final QName qname) {
+        return new ConcreteTypeBuilder<>(baseType, qname) {
             @Override
             public Uint64TypeDefinition buildType() {
-                return new DerivedUint64Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+                return new DerivedUint64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
                         getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
             }
         };