X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflowplugin%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fopenflow%2Fmd%2Fcore%2Fextension%2FExtensionConverterManagerImpl.java;h=4ce824a4b28a1155f84e3d8abc85850aad23bb4b;hb=6e5df2b3308ffdc906dc1ef84a4ddde37f8080f6;hp=8455c90a06aeb2a74ce03b4cc6eef95bfdf38057;hpb=8206680c49e0a3defd0fec47a231e821f7b6518e;p=openflowplugin.git

diff --git a/openflowplugin/src/main/java/org/opendaylight/openflowplugin/openflow/md/core/extension/ExtensionConverterManagerImpl.java b/openflowplugin/src/main/java/org/opendaylight/openflowplugin/openflow/md/core/extension/ExtensionConverterManagerImpl.java
index 8455c90a06..4ce824a4b2 100644
--- a/openflowplugin/src/main/java/org/opendaylight/openflowplugin/openflow/md/core/extension/ExtensionConverterManagerImpl.java
+++ b/openflowplugin/src/main/java/org/opendaylight/openflowplugin/openflow/md/core/extension/ExtensionConverterManagerImpl.java
@@ -7,43 +7,51 @@
  */
 package org.opendaylight.openflowplugin.openflow.md.core.extension;
 
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import org.opendaylight.openflowjava.protocol.api.keys.ActionSerializerKey;
-import org.opendaylight.openflowjava.protocol.api.keys.ExperimenterActionSerializerKey;
 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntrySerializerKey;
 import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
 import org.opendaylight.openflowplugin.extension.api.ConverterExtensionKey;
 import org.opendaylight.openflowplugin.extension.api.ConvertorActionFromOFJava;
 import org.opendaylight.openflowplugin.extension.api.ConvertorActionToOFJava;
 import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
+import org.opendaylight.openflowplugin.extension.api.ConvertorMessageFromOFJava;
+import org.opendaylight.openflowplugin.extension.api.ConverterMessageToOFJava;
 import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
 import org.opendaylight.openflowplugin.extension.api.TypeVersionKey;
+import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterManager;
 import org.opendaylight.openflowplugin.extension.api.path.ActionPath;
 import org.opendaylight.openflowplugin.extension.api.path.AugmentationPath;
 import org.opendaylight.openflowplugin.extension.api.path.MatchPath;
+import org.opendaylight.openflowplugin.extension.api.path.MessagePath;
 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserActionFromOFJava;
 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserActionToOFJava;
 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserFromOFJava;
+import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserMessageFromOFJava;
+import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserMessageToOFJava;
 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserToOFJava;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.MatchField;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OxmClassBase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.experimenter.types.rev151020.experimenter.core.message.ExperimenterMessageOfChoice;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.ExtensionKey;
 import org.opendaylight.yangtools.concepts.ObjectRegistration;
 import org.opendaylight.yangtools.yang.binding.DataContainer;
 
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
 /**
  * simple map-based registration engine implementation
  */
 public class ExtensionConverterManagerImpl implements ExtensionConverterManager {
 
-    private Map<MessageTypeKey<?>, ConvertorFromOFJava<?, ?>> registryFromOFJAva;
-    private Map<ConverterExtensionKey<?>, ConvertorToOFJava<?>> registryToOFJAva;
-    private Map<TypeVersionKey<? extends Action>, ConvertorActionToOFJava<? extends Action, ? extends DataContainer>> registryActionToOFJAva;
-    private Map<MessageTypeKey<?>, ConvertorActionFromOFJava<?, ?>> registryActionFromOFJAva;
+    private final Map<MessageTypeKey<?>, ConvertorFromOFJava<?, ?>> registryFromOFJAva;
+    private final Map<ConverterExtensionKey<?>, ConvertorToOFJava<?>> registryToOFJAva;
+    private final Map<TypeVersionKey<? extends Action>, ConvertorActionToOFJava<? extends Action, ? extends DataContainer>> registryActionToOFJAva;
+    private final Map<MessageTypeKey<?>, ConvertorActionFromOFJava<?, ?>> registryActionFromOFJAva;
+    private final Map<TypeVersionKey<?>, ConverterMessageToOFJava<? extends ExperimenterMessageOfChoice, ? extends DataContainer>> registryMessageToOFJAva;
+    private final Map<MessageTypeKey<?>, ConvertorMessageFromOFJava<? extends ExperimenterDataOfChoice, MessagePath>> registryMessageFromOFJAva;
 
     /**
      * default ctor
@@ -53,16 +61,18 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
         registryToOFJAva = new ConcurrentHashMap<>();
         registryActionToOFJAva = new ConcurrentHashMap<>();
         registryActionFromOFJAva = new ConcurrentHashMap<>();
+        registryMessageToOFJAva = new ConcurrentHashMap<>();
+        registryMessageFromOFJAva = new ConcurrentHashMap<>();
     }
 
     /**
-     * @param key
-     * @param extConvertor
-     * @return
+     * @param key message key
+     * @param extConvertor extension convertor
+     * @return registration closure
      */
     private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
     RegistrationCloserFromOFJava<FROM, PATH> hireJanitor(
-            KEY key, ConvertorFromOFJava<FROM, PATH> extConvertor) {
+            final KEY key, final ConvertorFromOFJava<FROM, PATH> extConvertor) {
         RegistrationCloserFromOFJava<FROM, PATH> janitor = new RegistrationCloser.RegistrationCloserFromOFJava<>();
         janitor.setConverter(extConvertor);
         janitor.setKey(key);
@@ -71,13 +81,13 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
     }
 
     /**
-     * @param key
-     * @param extConvertor
-     * @return
+     * @param key message type key
+     * @param extConvertor extension convertor
+     * @return registration closure
      */
     private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
     RegistrationCloserActionFromOFJava<FROM, PATH> hireJanitor(
-            KEY key, ConvertorActionFromOFJava<FROM, PATH> extConvertor) {
+            final KEY key, final ConvertorActionFromOFJava<FROM, PATH> extConvertor) {
         RegistrationCloserActionFromOFJava<FROM, PATH> janitor = new RegistrationCloser.RegistrationCloserActionFromOFJava<>();
         janitor.setConverter(extConvertor);
         janitor.setKey(key);
@@ -86,12 +96,12 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
     }
 
     /**
-     * @param key
-     * @param extConvertor
-     * @return
+     * @param key message type key
+     * @param extConvertor extension convertor
+     * @return registration closure
      */
     private <TO extends DataContainer> RegistrationCloserToOFJava<TO> hireJanitor(
-            ConverterExtensionKey<? extends ExtensionKey> key, ConvertorToOFJava<TO> extConvertor) {
+            final ConverterExtensionKey<? extends ExtensionKey> key, final ConvertorToOFJava<TO> extConvertor) {
         RegistrationCloserToOFJava<TO> janitor = new RegistrationCloser.RegistrationCloserToOFJava<>();
         janitor.setConverter(extConvertor);
         janitor.setKey(key);
@@ -100,12 +110,12 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
     }
 
     /**
-     * @param key
-     * @param extConvertor
-     * @return
+     * @param key message type key
+     * @param extConvertor extension convertor
+     * @return registration closure
      */
     private <TO extends DataContainer> RegistrationCloserActionToOFJava<TO> hireJanitor(
-            TypeVersionKey<? extends Action> key, ConvertorActionToOFJava<Action, TO> extConvertor) {
+            final TypeVersionKey<? extends Action> key, final ConvertorActionToOFJava<Action, TO> extConvertor) {
         RegistrationCloserActionToOFJava<TO> janitor = new RegistrationCloser.RegistrationCloserActionToOFJava<>();
         janitor.setConverter(extConvertor);
         janitor.setKey(key);
@@ -113,13 +123,43 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
         return janitor;
     }
 
+    /**
+     * @param key message type key
+     * @param extConvertor extension convertor
+     * @return registration closure
+     */
+    private <TO extends DataContainer, K extends ExperimenterMessageOfChoice> RegistrationCloserMessageToOFJava<TO, K> hireMessageJanitor(
+            final TypeVersionKey<K> key,
+            final ConverterMessageToOFJava<K, TO> extConvertor) {
+        RegistrationCloserMessageToOFJava<TO, K> janitor = new RegistrationCloserMessageToOFJava<>();
+        janitor.setConverter(extConvertor);
+        janitor.setKey(key);
+        janitor.setRegistrator(this);
+        return janitor;
+    }
+
+    /**
+     * @param key message type key
+     * @param extConvertor extension convertor
+     * @return registration closure
+     */
+    private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
+    RegistrationCloserMessageFromOFJava<FROM, PATH> hireMessageJanitor(
+            final KEY key, final ConvertorMessageFromOFJava<FROM, PATH> extConvertor) {
+        RegistrationCloserMessageFromOFJava<FROM, PATH> janitor = new RegistrationCloserMessageFromOFJava<>();
+        janitor.setConverter(extConvertor);
+        janitor.setKey(key);
+        janitor.setRegistrator(this);
+        return janitor;
+    }
+
     /**
      * cancel registration of given converter
      *
-     * @param key
-     * @param converter
+     * @param key message key
+     * @param converter extension convertor
      */
-    public void unregister(ConverterExtensionKey<?> key, ConvertorToOFJava<?> converter) {
+    public void unregister(final ConverterExtensionKey<?> key, final ConvertorToOFJava<?> converter) {
         ConvertorToOFJava<?> registeredConverter = registryToOFJAva.get(key);
         if (registeredConverter != null && registeredConverter == converter) {
             registryToOFJAva.remove(key);
@@ -129,10 +169,10 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
     /**
      * cancel registration of given converter
      *
-     * @param key
-     * @param converter
+     * @param key message key
+     * @param converter extension convertor
      */
-    public void unregister(TypeVersionKey<? extends Action> key, ConvertorActionToOFJava<?, ?> converter) {
+    public void unregister(final TypeVersionKey<? extends Action> key, final ConvertorActionToOFJava<?, ?> converter) {
         ConvertorActionToOFJava<?, ?> registeredConverter = registryActionToOFJAva.get(key);
         if (registeredConverter != null && registeredConverter == converter) {
             registryActionToOFJAva.remove(key);
@@ -142,10 +182,10 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
     /**
      * cancel registration of given converter
      *
-     * @param key
-     * @param converter
+     * @param key message key
+     * @param converter extension convertor
      */
-    public void unregister(MessageTypeKey<?> key, ConvertorFromOFJava<?, ?> converter) {
+    public void unregister(final MessageTypeKey<?> key, final ConvertorFromOFJava<?, ?> converter) {
         ConvertorFromOFJava<?, ?> registeredConverter = registryFromOFJAva.get(key);
         if (registeredConverter != null && registeredConverter == converter) {
             registryFromOFJAva.remove(key);
@@ -155,49 +195,75 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
     /**
      * cancel registration of given converter
      *
-     * @param key
-     * @param converter
+     * @param key message key
+     * @param converter extension convertor
      */
-    public void unregister(MessageTypeKey<?> key, ConvertorActionFromOFJava<?, ?> converter) {
+    public void unregister(final MessageTypeKey<?> key, final ConvertorActionFromOFJava<?, ?> converter) {
         ConvertorActionFromOFJava<?, ?> registeredConverter = registryActionFromOFJAva.get(key);
         if (registeredConverter != null && registeredConverter == converter) {
             registryActionFromOFJAva.remove(key);
         }
     }
 
+    /**
+     * cancel registration of given converter
+     *
+     * @param key message key
+     * @param converter extension convertor
+     */
+    public void unregister(final MessageTypeKey<?> key, final ConvertorMessageFromOFJava<?, ?> converter) {
+        ConvertorMessageFromOFJava<?, ?> registeredConverter = registryMessageFromOFJAva.get(key);
+        if (registeredConverter != null && registeredConverter == converter) {
+            registryMessageFromOFJAva.remove(key);
+        }
+    }
+
+    /**
+     * cancel registration of given converter
+     *
+     * @param key message key
+     * @param converter extension convertor
+     */
+    public void unregister(final TypeVersionKey<?> key, final ConverterMessageToOFJava<?, ?> converter) {
+        ConverterMessageToOFJava<?, ?> registeredConverter = registryMessageToOFJAva.get(key);
+        if (registeredConverter != null && registeredConverter == converter) {
+            registryMessageToOFJAva.remove(key);
+        }
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public <FROM extends DataContainer> ConvertorToOFJava<FROM> getConverter(
-            ConverterExtensionKey<?> key) {
+            final ConverterExtensionKey<?> key) {
         return (ConvertorToOFJava<FROM>) registryToOFJAva.get(key);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public <FROM extends Action, TO extends DataContainer> ConvertorActionToOFJava<FROM, TO> getConverter(
-            TypeVersionKey<FROM> key) {
+            final TypeVersionKey<FROM> key) {
         return (ConvertorActionToOFJava<FROM, TO>) registryActionToOFJAva.get(key);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public <FROM extends DataContainer, PATH extends AugmentationPath> ConvertorFromOFJava<FROM, PATH> getConverter(
-            MessageTypeKey<?> key) {
+            final MessageTypeKey<?> key) {
         return (ConvertorFromOFJava<FROM, PATH>) registryFromOFJAva.get(key);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public <FROM extends DataContainer, PATH extends AugmentationPath> ConvertorActionFromOFJava<FROM, PATH> getActionConverter(
-            MessageTypeKey<?> key) {
+            final MessageTypeKey<?> key) {
         return (ConvertorActionFromOFJava<FROM, PATH>) registryActionFromOFJAva.get(key);
     }
 
     @Override
     public ObjectRegistration<ConvertorActionToOFJava<Action, org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action>>
     registerActionConvertor(
-            TypeVersionKey<? extends Action> key,
-            ConvertorActionToOFJava<Action, org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action> convertor) {
+            final TypeVersionKey<? extends Action> key,
+            final ConvertorActionToOFJava<Action, org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action> convertor) {
         registryActionToOFJAva.put(key, convertor);
         return hireJanitor(key, convertor);
     }
@@ -205,25 +271,48 @@ public class ExtensionConverterManagerImpl implements ExtensionConverterManager
     @Override
     public ObjectRegistration<ConvertorActionFromOFJava<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action, ActionPath>>
     registerActionConvertor(
-            ActionSerializerKey<?> key,
-            ConvertorActionFromOFJava<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action, ActionPath> convertor) {
+            final ActionSerializerKey<?> key,
+            final ConvertorActionFromOFJava<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action, ActionPath> convertor) {
         registryActionFromOFJAva.put(key, convertor);
         return hireJanitor(key, convertor);
     }
 
     @Override
-    public ObjectRegistration<ConvertorToOFJava<MatchEntry>> registerMatchConvertor(ConverterExtensionKey<? extends ExtensionKey> key,
-                                                                                      ConvertorToOFJava<MatchEntry> convertor) {
+    public ObjectRegistration<ConvertorToOFJava<MatchEntry>> registerMatchConvertor(final ConverterExtensionKey<? extends ExtensionKey> key,
+                                                                                      final ConvertorToOFJava<MatchEntry> convertor) {
         registryToOFJAva.put(key, convertor);
         return hireJanitor(key, convertor);
     }
 
     @Override
     public ObjectRegistration<ConvertorFromOFJava<MatchEntry, MatchPath>> registerMatchConvertor(
-            MatchEntrySerializerKey<? extends OxmClassBase, ? extends MatchField> key,
-            ConvertorFromOFJava<MatchEntry, MatchPath> convertor) {
+            final MatchEntrySerializerKey<? extends OxmClassBase, ? extends MatchField> key,
+            final ConvertorFromOFJava<MatchEntry, MatchPath> convertor) {
         registryFromOFJAva.put(key, convertor);
         return hireJanitor(key, convertor);
     }
 
+    @Override
+    public <I extends ExperimenterMessageOfChoice, O extends DataContainer> ObjectRegistration<ConverterMessageToOFJava<I, O>> registerMessageConvertor(
+            TypeVersionKey<I> key, ConverterMessageToOFJava<I, O> convertor) {
+        registryMessageToOFJAva.put(key, convertor);
+        return hireMessageJanitor(key, convertor);
+    }
+
+    @Override
+    public <I extends ExperimenterDataOfChoice> ObjectRegistration<ConvertorMessageFromOFJava<I, MessagePath>> registerMessageConvertor(
+            MessageTypeKey<?> key, ConvertorMessageFromOFJava<I, MessagePath> convertor) {
+        registryMessageFromOFJAva.put(key, convertor);
+        return hireMessageJanitor(key, convertor);
+    }
+
+    @Override
+    public <F extends ExperimenterMessageOfChoice, T extends DataContainer> ConverterMessageToOFJava<F, T> getMessageConverter(TypeVersionKey<F> key) {
+        return (ConverterMessageToOFJava<F, T>) registryMessageToOFJAva.get(key);
+    }
+
+    @Override
+    public <F extends DataContainer, P extends AugmentationPath> ConvertorMessageFromOFJava<F, P> getMessageConverter(MessageTypeKey<?> key) {
+        return (ConvertorMessageFromOFJava<F, P>) registryMessageFromOFJAva.get(key);
+    }
 }