*/
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
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);
}
/**
- * @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);
}
/**
- * @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);
}
/**
- * @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);
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);
/**
* 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);
/**
* 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);
/**
* 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);
}
@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);
+ }
}
Code Review / openflowplugin.git / blobdiff