Clean up AugmentationCodecContext

[yangtools.git] / binding / mdsal-binding-dom-codec / src / main / java / org / opendaylight / mdsal / binding / dom / codec / impl / EnumerationCodec.java

diff --git a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/EnumerationCodec.java b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/EnumerationCodec.java
index 3b29d23db9210441e8e70dc93039e23a64c7711f..6de6d512234420cae6f8ef9a78170319bff34242 100644 (file)
--- a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/EnumerationCodec.java
+++ b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/EnumerationCodec.java
@@ -8,6 +8,7 @@
 package org.opendaylight.mdsal.binding.dom.codec.impl;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verifyNotNull;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.cache.Cache;
@@ -20,13 +21,13 @@ import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.binding.Enumeration;
+import org.opendaylight.yangtools.yang.binding.EnumTypeObject;
 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-final class EnumerationCodec extends ValueTypeCodec implements SchemaUnawareCodec {
+final class EnumerationCodec extends SchemaUnawareCodec {
     private static final Logger LOG = LoggerFactory.getLogger(EnumerationCodec.class);
     /*
      * Use identity comparison for keys and allow classes to be GCd themselves.
@@ -38,8 +39,8 @@ final class EnumerationCodec extends ValueTypeCodec implements SchemaUnawareCode
      *     "Virtual machine implementations are, however, encouraged to bias against clearing recently-created or
      *      recently-used soft references."
      */
-    private static final Cache<Class<?>, @NonNull EnumerationCodec> CACHE = CacheBuilder.newBuilder().weakKeys()
-        .softValues().build();
+    private static final Cache<Class<? extends EnumTypeObject>, @NonNull EnumerationCodec> CACHE =
+        CacheBuilder.newBuilder().weakKeys().softValues().build();
 
     private final ImmutableBiMap<String, Enum<?>> nameToEnum;
     private final Class<? extends Enum<?>> enumClass;
@@ -51,14 +52,14 @@ final class EnumerationCodec extends ValueTypeCodec implements SchemaUnawareCode
 
     static @NonNull EnumerationCodec of(final Class<?> returnType, final EnumTypeDefinition def)
             throws ExecutionException {
-        return CACHE.get(returnType, () -> {
+        return CACHE.get(returnType.asSubclass(EnumTypeObject.class), () -> {
             final Class<? extends Enum<?>> enumType = castType(returnType);
 
             final Map<String, Enum<?>> mapping = Maps.uniqueIndex(Arrays.asList(enumType.getEnumConstants()),
                 value -> {
-                    checkArgument(value instanceof Enumeration,
-                        "Enumeration constant %s.%s is not implementing Enumeration", enumType.getName(), value);
-                    return ((Enumeration) value).getName();
+                    checkArgument(value instanceof EnumTypeObject,
+                        "Enumeration constant %s.%s is not implementing EnumTypeObject", enumType.getName(), value);
+                    return ((EnumTypeObject) value).getName();
                 });
 
             // Check if mapping is a bijection
@@ -82,11 +83,11 @@ final class EnumerationCodec extends ValueTypeCodec implements SchemaUnawareCode
     @SuppressWarnings("unchecked")
     private static Class<? extends Enum<?>> castType(final Class<?> returnType) {
         checkArgument(Enum.class.isAssignableFrom(returnType));
-        return (Class<? extends Enum<?>>) returnType;
+        return (Class<? extends Enum<?>>) returnType.asSubclass(Enum.class);
     }
 
     @Override
-    public Enum<?> deserialize(final Object input) {
+    protected Enum<?> deserializeImpl(final Object input) {
         checkArgument(input instanceof String, "Input %s is not a String", input);
         final Enum<?> value = nameToEnum.get(input);
         checkArgument(value != null, "Invalid enumeration value %s. Valid values are %s", input, nameToEnum.keySet());
@@ -94,8 +95,8 @@ final class EnumerationCodec extends ValueTypeCodec implements SchemaUnawareCode
     }
 
     @Override
-    public String serialize(final Object input) {
+    protected String serializeImpl(final Object input) {
         checkArgument(enumClass.isInstance(input), "Input %s is not a instance of %s", input, enumClass);
-        return requireNonNull(nameToEnum.inverse().get(input));
+        return verifyNotNull(nameToEnum.inverse().get(input));
     }
 }
\ No newline at end of file