Migrate DocumentedNode/Status to JDT annotations

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

diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractDerivedType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractDerivedType.java
index 601afb5bf344393c6763507ec9e6ff788578cdfa..1425ed43195fed3f3f79998aa8db374fed06ea19 100644 (file)
--- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractDerivedType.java
+++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractDerivedType.java
@@ -7,73 +7,62 @@
  */
 package org.opendaylight.yangtools.yang.model.util.type;
 
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
 import java.util.Collection;
-import java.util.List;
-import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.yang.common.QName;
+import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 
-abstract class AbstractDerivedType<T extends TypeDefinition<T>> implements Immutable, TypeDefinition<T> {
-    private final SchemaPath path;
-    private final T baseType;
+abstract class AbstractDerivedType<T extends TypeDefinition<T>> extends AbstractTypeDefinition<T> {
+    private final @NonNull T baseType;
     private final Object defaultValue;
     private final String description;
     private final String reference;
-    private final Status status;
+    private final @NonNull Status status;
     private final String units;
-    private final List<UnknownSchemaNode> unknownSchemNodes;
 
     AbstractDerivedType(final T baseType, final SchemaPath path, final Object defaultValue, final String description,
-            final String reference, final Status status, final String units, final Collection<UnknownSchemaNode> unknownSchemNodes) {
-        this.baseType = Preconditions.checkNotNull(baseType);
-        this.path = Preconditions.checkNotNull(path);
-        this.status = Preconditions.checkNotNull(status);
+            final String reference, final Status status, final String units,
+            final Collection<UnknownSchemaNode> unknownSchemNodes) {
+        super(path, unknownSchemNodes);
+        this.baseType = requireNonNull(baseType);
+        this.status = requireNonNull(status);
         this.defaultValue = defaultValue;
         this.description = description;
         this.reference = reference;
         this.units = units;
-        this.unknownSchemNodes = ImmutableList.copyOf(unknownSchemNodes);
     }
 
     @Override
     public final T getBaseType() {
-        return baseType;
-    }
-
-    @Override
-    public final Object getDefaultValue() {
-        return defaultValue != null ? defaultValue : baseType.getDefaultValue();
+        return baseType instanceof AbstractRestrictedType ? baseType.getBaseType() : baseType;
     }
 
-    @Override
-    public final QName getQName() {
-        return path.getLastComponent();
-    }
-
-    @Override
-    public final SchemaPath getPath() {
-        return path;
+    /**
+     * Return the stored base type. Unlike {@link #getBaseType()}, this method returns the underlying restricted type.
+     */
+    final T baseType() {
+        return baseType;
     }
 
     @Override
-    public final List<UnknownSchemaNode> getUnknownSchemaNodes() {
-        return unknownSchemNodes;
+    public final Optional<? extends Object> getDefaultValue() {
+        return defaultValue != null ? Optional.of(defaultValue) : baseType.getDefaultValue();
     }
 
     @Override
-    public final String getDescription() {
-        return description;
+    public final Optional<String> getDescription() {
+        return Optional.ofNullable(description);
     }
 
     @Override
-    public final String getReference() {
-        return reference;
+    public final Optional<String> getReference() {
+        return Optional.ofNullable(reference);
     }
 
     @Override
@@ -82,14 +71,19 @@ abstract class AbstractDerivedType<T extends TypeDefinition<T>> implements Immut
     }
 
     @Override
-    public final String getUnits() {
-        return units != null ? units : baseType.getUnits();
+    public final Optional<String> getUnits() {
+        return units != null ? Optional.of(units) : baseType.getUnits();
     }
 
     @Override
     public final String toString() {
-        return MoreObjects.toStringHelper(this).omitNullValues().add("baseType", baseType).add("default", defaultValue)
-                .add("description", description).add("path", path).add("reference", reference).add("status", status)
+        return MoreObjects.toStringHelper(this).omitNullValues()
+                .add("baseType", baseType)
+                .add("default", defaultValue)
+                .add("description", description)
+                .add("path", getPath())
+                .add("reference", reference)
+                .add("status", status)
                 .add("units", units).toString();
     }
 }