openflowplugin/src/main/java/org/opendaylight/openflowplugin/openflow/md/core/extension/ExtensionConverterManagerImpl.java

   1 /**
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.openflowplugin.openflow.md.core.extension;
   9
  10 import java.util.Map;
  11 import java.util.concurrent.ConcurrentHashMap;
  12 import org.opendaylight.openflowjava.protocol.api.keys.ActionSerializerKey;
  13 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntrySerializerKey;
  14 import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
  15 import org.opendaylight.openflowplugin.extension.api.ConverterExtensionKey;
  16 import org.opendaylight.openflowplugin.extension.api.ConvertorActionFromOFJava;
  17 import org.opendaylight.openflowplugin.extension.api.ConvertorActionToOFJava;
  18 import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
  19 import org.opendaylight.openflowplugin.extension.api.ConvertorMessageFromOFJava;
  20 import org.opendaylight.openflowplugin.extension.api.ConvertorMessageToOFJava;
  21 import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
  22 import org.opendaylight.openflowplugin.extension.api.TypeVersionKey;
  23 import org.opendaylight.openflowplugin.extension.api.path.ActionPath;
  24 import org.opendaylight.openflowplugin.extension.api.path.AugmentationPath;
  25 import org.opendaylight.openflowplugin.extension.api.path.MatchPath;
  26 import org.opendaylight.openflowplugin.extension.api.path.MessagePath;
  27 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserActionFromOFJava;
  28 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserActionToOFJava;
  29 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserFromOFJava;
  30 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserMessageFromOFJava;
  31 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserMessageToOFJava;
  32 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserToOFJava;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.MatchField;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OxmClassBase;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.experimenter.types.rev151020.experimenter.core.message.ExperimenterMessageOfChoice;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.ExtensionKey;
  40 import org.opendaylight.yangtools.concepts.ObjectRegistration;
  41 import org.opendaylight.yangtools.yang.binding.DataContainer;
  42
  43 /**
  44  * simple map-based registration engine implementation
  45  */
  46 public class ExtensionConverterManagerImpl implements ExtensionConverterManager {
  47
  48     private final Map<MessageTypeKey<?>, ConvertorFromOFJava<?, ?>> registryFromOFJAva;
  49     private final Map<ConverterExtensionKey<?>, ConvertorToOFJava<?>> registryToOFJAva;
  50     private final Map<TypeVersionKey<? extends Action>, ConvertorActionToOFJava<? extends Action, ? extends DataContainer>> registryActionToOFJAva;
  51     private final Map<MessageTypeKey<?>, ConvertorActionFromOFJava<?, ?>> registryActionFromOFJAva;
  52     private final Map<TypeVersionKey<?>, ConvertorMessageToOFJava<ExperimenterMessageOfChoice, DataContainer>> registryMessageToOFJAva;
  53     private final Map<MessageTypeKey<?>, ConvertorMessageFromOFJava<ExperimenterDataOfChoice, MessagePath>> registryMessageFromOFJAva;
  54
  55     /**
  56      * default ctor
  57      */
  58     public ExtensionConverterManagerImpl() {
  59         registryFromOFJAva = new ConcurrentHashMap<>();
  60         registryToOFJAva = new ConcurrentHashMap<>();
  61         registryActionToOFJAva = new ConcurrentHashMap<>();
  62         registryActionFromOFJAva = new ConcurrentHashMap<>();
  63         registryMessageToOFJAva = new ConcurrentHashMap<>();
  64         registryMessageFromOFJAva = new ConcurrentHashMap<>();
  65     }
  66
  67     /**
  68      * @param key
  69      * @param extConvertor
  70      * @return
  71      */
  72     private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
  73     RegistrationCloserFromOFJava<FROM, PATH> hireJanitor(
  74             final KEY key, final ConvertorFromOFJava<FROM, PATH> extConvertor) {
  75         RegistrationCloserFromOFJava<FROM, PATH> janitor = new RegistrationCloser.RegistrationCloserFromOFJava<>();
  76         janitor.setConverter(extConvertor);
  77         janitor.setKey(key);
  78         janitor.setRegistrator(this);
  79         return janitor;
  80     }
  81
  82     /**
  83      * @param key
  84      * @param extConvertor
  85      * @return
  86      */
  87     private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
  88     RegistrationCloserActionFromOFJava<FROM, PATH> hireJanitor(
  89             final KEY key, final ConvertorActionFromOFJava<FROM, PATH> extConvertor) {
  90         RegistrationCloserActionFromOFJava<FROM, PATH> janitor = new RegistrationCloser.RegistrationCloserActionFromOFJava<>();
  91         janitor.setConverter(extConvertor);
  92         janitor.setKey(key);
  93         janitor.setRegistrator(this);
  94         return janitor;
  95     }
  96
  97     /**
  98      * @param key
  99      * @param extConvertor
 100      * @return
 101      */
 102     private <TO extends DataContainer> RegistrationCloserToOFJava<TO> hireJanitor(
 103             final ConverterExtensionKey<? extends ExtensionKey> key, final ConvertorToOFJava<TO> extConvertor) {
 104         RegistrationCloserToOFJava<TO> janitor = new RegistrationCloser.RegistrationCloserToOFJava<>();
 105         janitor.setConverter(extConvertor);
 106         janitor.setKey(key);
 107         janitor.setRegistrator(this);
 108         return janitor;
 109     }
 110
 111     /**
 112      * @param key
 113      * @param extConvertor
 114      * @return
 115      */
 116     private <TO extends DataContainer> RegistrationCloserActionToOFJava<TO> hireJanitor(
 117             final TypeVersionKey<? extends Action> key, final ConvertorActionToOFJava<Action, TO> extConvertor) {
 118         RegistrationCloserActionToOFJava<TO> janitor = new RegistrationCloser.RegistrationCloserActionToOFJava<>();
 119         janitor.setConverter(extConvertor);
 120         janitor.setKey(key);
 121         janitor.setRegistrator(this);
 122         return janitor;
 123     }
 124
 125     /**
 126      * @param key
 127      * @param extConvertor
 128      * @return
 129      */
 130     private <TO extends DataContainer> RegistrationCloserMessageToOFJava<TO> hireMessageJanitor(
 131             final TypeVersionKey<? extends ExperimenterMessageOfChoice> key,
 132             final ConvertorMessageToOFJava<ExperimenterMessageOfChoice, TO> extConvertor) {
 133         RegistrationCloserMessageToOFJava<TO> janitor = new RegistrationCloserMessageToOFJava<>();
 134         janitor.setConverter(extConvertor);
 135         janitor.setKey(key);
 136         janitor.setRegistrator(this);
 137         return janitor;
 138     }
 139
 140     /**
 141      * @param key
 142      * @param extConvertor
 143      * @return
 144      */
 145     private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
 146     RegistrationCloserMessageFromOFJava<FROM, PATH> hireMessageJanitor(
 147             final KEY key, final ConvertorMessageFromOFJava<FROM, PATH> extConvertor) {
 148         RegistrationCloserMessageFromOFJava<FROM, PATH> janitor = new RegistrationCloserMessageFromOFJava<>();
 149         janitor.setConverter(extConvertor);
 150         janitor.setKey(key);
 151         janitor.setRegistrator(this);
 152         return janitor;
 153     }
 154
 155     /**
 156      * cancel registration of given converter
 157      *
 158      * @param key
 159      * @param converter
 160      */
 161     public void unregister(final ConverterExtensionKey<?> key, final ConvertorToOFJava<?> converter) {
 162         ConvertorToOFJava<?> registeredConverter = registryToOFJAva.get(key);
 163         if (registeredConverter != null && registeredConverter == converter) {
 164             registryToOFJAva.remove(key);
 165         }
 166     }
 167
 168     /**
 169      * cancel registration of given converter
 170      *
 171      * @param key
 172      * @param converter
 173      */
 174     public void unregister(final TypeVersionKey<? extends Action> key, final ConvertorActionToOFJava<?, ?> converter) {
 175         ConvertorActionToOFJava<?, ?> registeredConverter = registryActionToOFJAva.get(key);
 176         if (registeredConverter != null && registeredConverter == converter) {
 177             registryActionToOFJAva.remove(key);
 178         }
 179     }
 180
 181     /**
 182      * cancel registration of given converter
 183      *
 184      * @param key
 185      * @param converter
 186      */
 187     public void unregister(final MessageTypeKey<?> key, final ConvertorFromOFJava<?, ?> converter) {
 188         ConvertorFromOFJava<?, ?> registeredConverter = registryFromOFJAva.get(key);
 189         if (registeredConverter != null && registeredConverter == converter) {
 190             registryFromOFJAva.remove(key);
 191         }
 192     }
 193
 194     /**
 195      * cancel registration of given converter
 196      *
 197      * @param key
 198      * @param converter
 199      */
 200     public void unregister(final MessageTypeKey<?> key, final ConvertorActionFromOFJava<?, ?> converter) {
 201         ConvertorActionFromOFJava<?, ?> registeredConverter = registryActionFromOFJAva.get(key);
 202         if (registeredConverter != null && registeredConverter == converter) {
 203             registryActionFromOFJAva.remove(key);
 204         }
 205     }
 206
 207     /**
 208      * cancel registration of given converter
 209      *
 210      * @param key
 211      * @param converter
 212      */
 213     public void unregister(final MessageTypeKey<?> key, final ConvertorMessageFromOFJava<?, ?> converter) {
 214         ConvertorMessageFromOFJava<?, ?> registeredConverter = registryMessageFromOFJAva.get(key);
 215         if (registeredConverter != null && registeredConverter == converter) {
 216             registryMessageFromOFJAva.remove(key);
 217         }
 218     }
 219
 220     /**
 221      * cancel registration of given converter
 222      *
 223      * @param key
 224      * @param converter
 225      */
 226     public void unregister(final TypeVersionKey<?> key, final ConvertorMessageToOFJava<?, ?> converter) {
 227         ConvertorMessageToOFJava<?, ?> registeredConverter = registryMessageToOFJAva.get(key);
 228         if (registeredConverter != null && registeredConverter == converter) {
 229             registryMessageToOFJAva.remove(key);
 230         }
 231     }
 232
 233     @SuppressWarnings("unchecked")
 234     @Override
 235     public <FROM extends DataContainer> ConvertorToOFJava<FROM> getConverter(
 236             final ConverterExtensionKey<?> key) {
 237         return (ConvertorToOFJava<FROM>) registryToOFJAva.get(key);
 238     }
 239
 240     @SuppressWarnings("unchecked")
 241     @Override
 242     public <FROM extends Action, TO extends DataContainer> ConvertorActionToOFJava<FROM, TO> getConverter(
 243             final TypeVersionKey<FROM> key) {
 244         return (ConvertorActionToOFJava<FROM, TO>) registryActionToOFJAva.get(key);
 245     }
 246
 247     @SuppressWarnings("unchecked")
 248     @Override
 249     public <FROM extends DataContainer, PATH extends AugmentationPath> ConvertorFromOFJava<FROM, PATH> getConverter(
 250             final MessageTypeKey<?> key) {
 251         return (ConvertorFromOFJava<FROM, PATH>) registryFromOFJAva.get(key);
 252     }
 253
 254     @SuppressWarnings("unchecked")
 255     @Override
 256     public <FROM extends DataContainer, PATH extends AugmentationPath> ConvertorActionFromOFJava<FROM, PATH> getActionConverter(
 257             final MessageTypeKey<?> key) {
 258         return (ConvertorActionFromOFJava<FROM, PATH>) registryActionFromOFJAva.get(key);
 259     }
 260
 261     @Override
 262     public ObjectRegistration<ConvertorActionToOFJava<Action, org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action>>
 263     registerActionConvertor(
 264             final TypeVersionKey<? extends Action> key,
 265             final ConvertorActionToOFJava<Action, org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action> convertor) {
 266         registryActionToOFJAva.put(key, convertor);
 267         return hireJanitor(key, convertor);
 268     }
 269
 270     @Override
 271     public ObjectRegistration<ConvertorActionFromOFJava<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action, ActionPath>>
 272     registerActionConvertor(
 273             final ActionSerializerKey<?> key,
 274             final ConvertorActionFromOFJava<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions.grouping.Action, ActionPath> convertor) {
 275         registryActionFromOFJAva.put(key, convertor);
 276         return hireJanitor(key, convertor);
 277     }
 278
 279     @Override
 280     public ObjectRegistration<ConvertorToOFJava<MatchEntry>> registerMatchConvertor(final ConverterExtensionKey<? extends ExtensionKey> key,
 281                                                                                       final ConvertorToOFJava<MatchEntry> convertor) {
 282         registryToOFJAva.put(key, convertor);
 283         return hireJanitor(key, convertor);
 284     }
 285
 286     @Override
 287     public ObjectRegistration<ConvertorFromOFJava<MatchEntry, MatchPath>> registerMatchConvertor(
 288             final MatchEntrySerializerKey<? extends OxmClassBase, ? extends MatchField> key,
 289             final ConvertorFromOFJava<MatchEntry, MatchPath> convertor) {
 290         registryFromOFJAva.put(key, convertor);
 291         return hireJanitor(key, convertor);
 292     }
 293
 294     @Override
 295     public ObjectRegistration<ConvertorMessageToOFJava<ExperimenterMessageOfChoice, DataContainer>> registerMessageConvertor(
 296             TypeVersionKey<? extends ExperimenterMessageOfChoice> key, ConvertorMessageToOFJava<ExperimenterMessageOfChoice, DataContainer> convertor) {
 297         registryMessageToOFJAva.put(key, convertor);
 298         return hireMessageJanitor(key, convertor);
 299     }
 300
 301     @Override
 302     public ObjectRegistration<ConvertorMessageFromOFJava<ExperimenterDataOfChoice, MessagePath>> registerMessageConvertor(
 303             MessageTypeKey<?> key, ConvertorMessageFromOFJava<ExperimenterDataOfChoice, MessagePath> convertor) {
 304         registryMessageFromOFJAva.put(key, convertor);
 305         return hireMessageJanitor(key, convertor);
 306     }
 307 }