Merge "Change in AbstractRaftBehavior#performSnapshotWithoutCapture"

[controller.git] / opendaylight / md-sal / sal-binding-broker / src / main / java / org / opendaylight / controller / md / sal / binding / impl / BindingToNormalizedNodeCodec.java

diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java
index d7314e5362873b0db2e3fa6a2a20b93f527725d2..d5b7d051b881c86db77a121546cceeec4072f627 100644 (file)
--- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java
+++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java
@@ -9,27 +9,33 @@ package org.opendaylight.controller.md.sal.binding.impl;
 
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
-
+import com.google.common.collect.ImmutableBiMap;
+import java.lang.reflect.Method;
 import java.util.Iterator;
 import java.util.Map.Entry;
-
 import javax.annotation.Nonnull;
-
 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException;
 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation;
 import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizer;
 import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry;
 import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
 import org.opendaylight.yangtools.sal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.yangtools.yang.binding.BindingMapping;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
 import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
 public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoCloseable {
 
@@ -37,6 +43,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC
     private final BindingNormalizedNodeCodecRegistry codecRegistry;
     private DataNormalizer legacyToNormalized;
     private final GeneratedClassLoadingStrategy classLoadingStrategy;
+    private BindingRuntimeContext runtimeContext;
 
     public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy, final BindingIndependentMappingService mappingService, final BindingNormalizedNodeCodecRegistry codecRegistry) {
         super();
@@ -75,7 +82,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC
                     throws DeserializationException {
         try {
             return Optional.<InstanceIdentifier<? extends DataObject>>fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized));
-        } catch (IllegalArgumentException e) {
+        } catch (final IllegalArgumentException e) {
             return Optional.absent();
         }
     }
@@ -102,17 +109,18 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC
              *
              */
             @SuppressWarnings({ "unchecked", "rawtypes" })
-            final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding = (Entry) codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue());
+            final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding = Entry.class.cast(codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue()));
             return Optional.fromNullable(binding);
-        } catch (IllegalArgumentException e) {
+        } catch (final IllegalArgumentException e) {
             return Optional.absent();
         }
     }
 
     @Override
     public void onGlobalContextUpdated(final SchemaContext arg0) {
-        legacyToNormalized = new DataNormalizer(arg0);
-        codecRegistry.onBindingRuntimeContextUpdated(BindingRuntimeContext.create(classLoadingStrategy, arg0));
+        legacyToNormalized = new DataNormalizer (arg0);
+        runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, arg0);
+        codecRegistry.onBindingRuntimeContextUpdated(runtimeContext);
     }
 
     public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>>  deserializeFunction(final InstanceIdentifier<T> path) {
@@ -126,13 +134,13 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC
      * @return Node with defaults set on.
      */
     public NormalizedNode<?, ?> getDefaultNodeFor(final YangInstanceIdentifier path) {
-        Iterator<PathArgument> iterator = path.getPathArguments().iterator();
+        final Iterator<PathArgument> iterator = path.getPathArguments().iterator();
         DataNormalizationOperation<?> currentOp = legacyToNormalized.getRootOperation();
         while (iterator.hasNext()) {
-            PathArgument currentArg = iterator.next();
+            final PathArgument currentArg = iterator.next();
             try {
                 currentOp = currentOp.getChild(currentArg);
-            } catch (DataNormalizationException e) {
+            } catch (final DataNormalizationException e) {
                 throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e);
             }
         }
@@ -143,8 +151,41 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoC
         return bindingToLegacy;
     }
 
+    public BindingNormalizedNodeCodecRegistry getCodecRegistry() {
+        return codecRegistry;
+    }
+
     @Override
     public void close() {
         // NOOP Intentionally
     }
+
+    public BindingNormalizedNodeCodecRegistry getCodecFactory() {
+        return codecRegistry;
+    }
+
+    // FIXME: This should be probably part of Binding Runtime context
+    public ImmutableBiMap<Method, SchemaPath> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
+        final QNameModule moduleName = BindingReflections.getQNameModule(key);
+        final Module module = runtimeContext.getSchemaContext().findModuleByNamespaceAndRevision(moduleName.getNamespace(), moduleName.getRevision());
+        final ImmutableBiMap.Builder<Method, SchemaPath> ret = ImmutableBiMap.<Method, SchemaPath>builder();
+        try {
+            for (final RpcDefinition rpcDef : module.getRpcs()) {
+                final Method method = findRpcMethod(key, rpcDef);
+                ret.put(method, rpcDef.getPath());
+            }
+        } catch (final NoSuchMethodException e) {
+            throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
+        }
+        return ret.build();
+    }
+
+    private Method findRpcMethod(final Class<? extends RpcService> key, final RpcDefinition rpcDef) throws NoSuchMethodException {
+        final String methodName = BindingMapping.getMethodName(rpcDef.getQName());
+        if(rpcDef.getInput() != null) {
+            final Class<?> inputClz = runtimeContext.getClassForSchema(rpcDef.getInput());
+            return key.getMethod(methodName, inputClz);
+        }
+        return key.getMethod(methodName);
+    }
 }