Add AbstractCodecFactory.LeafrefResolver

[yangtools.git] / yang / yang-data-util / src / main / java / org / opendaylight / yangtools / yang / data / util / codec / AbstractCodecFactory.java

diff --git a/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/codec/AbstractCodecFactory.java b/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/codec/AbstractCodecFactory.java
index 22e4d82cbcf49149b04a0de2edbf287dd5e9f08b..d5103ae6a3e83d86d771eec95b39b5a7c2c8f752 100644 (file)
--- a/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/codec/AbstractCodecFactory.java
+++ b/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/codec/AbstractCodecFactory.java
@@ -10,6 +10,7 @@ package org.opendaylight.yangtools.yang.data.util.codec;
 import static com.google.common.base.Verify.verifyNotNull;
 import static java.util.Objects.requireNonNull;
 
+import com.google.common.annotations.Beta;
 import java.util.ArrayList;
 import java.util.List;
 import org.eclipse.jdt.annotation.NonNull;
@@ -39,7 +40,6 @@ import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.UnknownTypeDefinition;
 import org.opendaylight.yangtools.yang.model.spi.AbstractEffectiveModelContextProvider;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -53,6 +53,21 @@ import org.slf4j.LoggerFactory;
  */
 public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>>
         extends AbstractEffectiveModelContextProvider {
+    /**
+     * Helper interface aiding resolution of leafref chains.
+     */
+    @Beta
+    @FunctionalInterface
+    public interface LeafrefResolver {
+        /**
+         * Resolve specified {@link LeafrefTypeDefinition}.
+         *
+         * @param type leafref definition
+         * @return Resolved type
+         */
+        @NonNull TypeDefinition<?> resolveLeafref(@NonNull LeafrefTypeDefinition type);
+    }
+
     private static final Logger LOG = LoggerFactory.getLogger(AbstractCodecFactory.class);
 
     private final @NonNull CodecCache<T> cache;
@@ -63,7 +78,8 @@ public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>>
         this.cache = requireNonNull(cache);
     }
 
-    public final <S extends TypeAware & SchemaNode> @NonNull T codecFor(final S schema) {
+    public final <S extends TypeAware & SchemaNode> @NonNull T codecFor(final S schema,
+            final LeafrefResolver resolver) {
         /*
          * There are many trade-offs to be made here. We need the common case being as fast as possible while reusing
          * codecs as much as possible.
@@ -96,7 +112,7 @@ public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>>
         }
 
         // ... and complex types afterwards
-        ret = createComplexCodecFor(schema, type);
+        ret = createComplexCodecFor(schema, type, resolver);
         LOG.trace("Type {} miss complex {}", type, ret);
         return cache.getComplex(schema, ret);
     }
@@ -208,16 +224,14 @@ public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>>
         return true;
     }
 
-    private T createComplexCodecFor(final SchemaNode schema, final TypeDefinition<?> type) {
+    private T createComplexCodecFor(final SchemaNode schema, final TypeDefinition<?> type,
+            final LeafrefResolver resolver) {
         if (type instanceof UnionTypeDefinition) {
-            return createComplexUnion(schema, (UnionTypeDefinition) type);
+            return createComplexUnion(schema, (UnionTypeDefinition) type, resolver);
         } else if (type instanceof LeafrefTypeDefinition) {
-            final TypeDefinition<?> target = SchemaContextUtil.getBaseTypeForLeafRef((LeafrefTypeDefinition) type,
-                getEffectiveModelContext(), schema);
-            verifyNotNull(target, "Unable to find base type for leafref node %s type %s.", schema, target);
-
+            final TypeDefinition<?> target = resolver.resolveLeafref((LeafrefTypeDefinition) type);
             final T ret = getSimpleCodecFor(target);
-            return ret != null ? ret : createComplexCodecFor(schema, target);
+            return ret != null ? ret : createComplexCodecFor(schema, target, resolver);
         } else if (type instanceof IdentityrefTypeDefinition) {
             return identityRefCodec((IdentityrefTypeDefinition) type, schema.getQName().getModule());
         } else {
@@ -241,7 +255,8 @@ public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>>
         return unionCodec(union, codecs);
     }
 
-    private T createComplexUnion(final SchemaNode schema, final UnionTypeDefinition union) {
+    private T createComplexUnion(final SchemaNode schema, final UnionTypeDefinition union,
+            final LeafrefResolver resolver) {
         final List<TypeDefinition<?>> types = union.getTypes();
         final List<T> codecs = new ArrayList<>(types.size());
 
@@ -250,11 +265,11 @@ public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>>
             if (codec == null) {
                 codec = getSimpleCodecFor(type);
                 if (codec == null) {
-                    codec = createComplexCodecFor(schema, type);
+                    codec = createComplexCodecFor(schema, type, resolver);
                 }
             }
 
-            codecs.add(verifyNotNull(codec, "Schema %s subtype %s has no codec", schema, type));
+            codecs.add(verifyNotNull(codec, "Type %s has no codec", schema, type));
         }
 
         return unionCodec(union, codecs);