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