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
  13 import org.opendaylight.openflowjava.protocol.api.extensibility.MessageTypeKey;
  14 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntrySerializerKey;
  15 import org.opendaylight.openflowjava.protocol.api.keys.experimenter.ExperimenterActionSerializerKey;
  16 import org.opendaylight.openflowplugin.extension.api.ConverterExtensionKey;
  17 import org.opendaylight.openflowplugin.extension.api.ConvertorActionFromOFJava;
  18 import org.opendaylight.openflowplugin.extension.api.ConvertorActionToOFJava;
  19 import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
  20 import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
  21 import org.opendaylight.openflowplugin.extension.api.TypeVersionKey;
  22 import org.opendaylight.openflowplugin.extension.api.path.ActionPath;
  23 import org.opendaylight.openflowplugin.extension.api.path.AugmentationPath;
  24 import org.opendaylight.openflowplugin.extension.api.path.MatchPath;
  25 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserActionFromOFJava;
  26 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserActionToOFJava;
  27 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserFromOFJava;
  28 import org.opendaylight.openflowplugin.openflow.md.core.extension.RegistrationCloser.RegistrationCloserToOFJava;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MatchField;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.OxmClassBase;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.oxm.fields.grouping.MatchEntries;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.ExtensionKey;
  34 import org.opendaylight.yangtools.concepts.ObjectRegistration;
  35 import org.opendaylight.yangtools.yang.binding.DataContainer;
  36
  37 /**
  38  * simple map-based registration engine implementation
  39  */
  40 public class ExtensionConverterManagerImpl implements ExtensionConverterManager {
  41
  42     private Map<MessageTypeKey<?>, ConvertorFromOFJava<?, ?>> registryFromOFJAva;
  43     private Map<ConverterExtensionKey<?>, ConvertorToOFJava<?>> registryToOFJAva;
  44     private Map<TypeVersionKey<? extends Action>, ConvertorActionToOFJava<? extends Action, ? extends DataContainer>> registryActionToOFJAva;
  45     private Map<MessageTypeKey<?>, ConvertorActionFromOFJava<?, ?>> registryActionFromOFJAva;
  46
  47     /**
  48      * default ctor
  49      */
  50     public ExtensionConverterManagerImpl() {
  51         registryFromOFJAva = new ConcurrentHashMap<>();
  52         registryToOFJAva = new ConcurrentHashMap<>();
  53         registryActionToOFJAva = new ConcurrentHashMap<>();
  54         registryActionFromOFJAva = new ConcurrentHashMap<>();
  55     }
  56
  57     /**
  58      * @param key
  59      * @param extConvertor
  60      * @return
  61      */
  62     private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
  63             RegistrationCloserFromOFJava<FROM, PATH> hireJanitor(
  64             KEY key, ConvertorFromOFJava<FROM, PATH> extConvertor) {
  65         RegistrationCloserFromOFJava<FROM, PATH> janitor = new RegistrationCloser.RegistrationCloserFromOFJava<>();
  66         janitor.setConverter(extConvertor);
  67         janitor.setKey(key);
  68         janitor.setRegistrator(this);
  69         return janitor;
  70     }
  71
  72     /**
  73      * @param key
  74      * @param extConvertor
  75      * @return
  76      */
  77     private <FROM extends DataContainer, PATH extends AugmentationPath, KEY extends MessageTypeKey<?>>
  78             RegistrationCloserActionFromOFJava<FROM, PATH> hireJanitor(
  79             KEY key, ConvertorActionFromOFJava<FROM, PATH> extConvertor) {
  80         RegistrationCloserActionFromOFJava<FROM, PATH> janitor = new RegistrationCloser.RegistrationCloserActionFromOFJava<>();
  81         janitor.setConverter(extConvertor);
  82         janitor.setKey(key);
  83         janitor.setRegistrator(this);
  84         return janitor;
  85     }
  86
  87     /**
  88      * @param key
  89      * @param extConvertor
  90      * @return
  91      */
  92     private <TO extends DataContainer> RegistrationCloserToOFJava<TO> hireJanitor(
  93             ConverterExtensionKey<? extends ExtensionKey> key, ConvertorToOFJava<TO> extConvertor) {
  94         RegistrationCloserToOFJava<TO> janitor = new RegistrationCloser.RegistrationCloserToOFJava<>();
  95         janitor.setConverter(extConvertor);
  96         janitor.setKey(key);
  97         janitor.setRegistrator(this);
  98         return janitor;
  99     }
 100
 101     /**
 102      * @param key
 103      * @param extConvertor
 104      * @return
 105      */
 106     private <TO extends DataContainer> RegistrationCloserActionToOFJava<TO> hireJanitor(
 107             TypeVersionKey<? extends Action> key, ConvertorActionToOFJava<Action, TO> extConvertor) {
 108         RegistrationCloserActionToOFJava<TO> janitor = new RegistrationCloser.RegistrationCloserActionToOFJava<>();
 109         janitor.setConverter(extConvertor);
 110         janitor.setKey(key);
 111         janitor.setRegistrator(this);
 112         return janitor;
 113     }
 114
 115     /**
 116      * cancel registration of given converter
 117      *
 118      * @param key
 119      * @param converter
 120      */
 121     public void unregister(ConverterExtensionKey<?> key, ConvertorToOFJava<?> converter) {
 122         ConvertorToOFJava<?> registeredConverter = registryToOFJAva.get(key);
 123         if (registeredConverter != null && registeredConverter == converter) {
 124             registryToOFJAva.remove(key);
 125         }
 126     }
 127
 128     /**
 129      * cancel registration of given converter
 130      *
 131      * @param key
 132      * @param converter
 133      */
 134     public void unregister(TypeVersionKey<? extends Action> key, ConvertorActionToOFJava<?, ?> converter) {
 135         ConvertorActionToOFJava<?, ?> registeredConverter = registryActionToOFJAva.get(key);
 136         if (registeredConverter != null && registeredConverter == converter) {
 137             registryActionToOFJAva.remove(key);
 138         }
 139     }
 140
 141     /**
 142      * cancel registration of given converter
 143      *
 144      * @param key
 145      * @param converter
 146      */
 147     public void unregister(MessageTypeKey<?> key, ConvertorFromOFJava<?, ?> converter) {
 148         ConvertorFromOFJava<?, ?> registeredConverter = registryFromOFJAva.get(key);
 149         if (registeredConverter != null && registeredConverter == converter) {
 150             registryFromOFJAva.remove(key);
 151         }
 152     }
 153
 154     /**
 155      * cancel registration of given converter
 156      *
 157      * @param key
 158      * @param converter
 159      */
 160     public void unregister(MessageTypeKey<?> key, ConvertorActionFromOFJava<?, ?> converter) {
 161         ConvertorActionFromOFJava<?, ?> registeredConverter = registryActionFromOFJAva.get(key);
 162         if (registeredConverter != null && registeredConverter == converter) {
 163             registryActionFromOFJAva.remove(key);
 164         }
 165     }
 166
 167     @SuppressWarnings("unchecked")
 168     @Override
 169     public <FROM extends DataContainer> ConvertorToOFJava<FROM> getConverter(
 170             ConverterExtensionKey<?> key) {
 171         return (ConvertorToOFJava<FROM>) registryToOFJAva.get(key);
 172     }
 173
 174     @SuppressWarnings("unchecked")
 175     @Override
 176     public <FROM extends Action, TO extends DataContainer> ConvertorActionToOFJava<FROM, TO> getConverter(
 177             TypeVersionKey<FROM> key) {
 178         return (ConvertorActionToOFJava<FROM, TO>) registryActionToOFJAva.get(key);
 179     }
 180
 181     @SuppressWarnings("unchecked")
 182     @Override
 183     public <FROM extends DataContainer, PATH extends AugmentationPath> ConvertorFromOFJava<FROM, PATH> getConverter(
 184             MessageTypeKey<?> key) {
 185         return (ConvertorFromOFJava<FROM, PATH>) registryFromOFJAva.get(key);
 186     }
 187
 188     @SuppressWarnings("unchecked")
 189     @Override
 190     public <FROM extends DataContainer, PATH extends AugmentationPath> ConvertorActionFromOFJava<FROM, PATH> getActionConverter(
 191             MessageTypeKey<?> key) {
 192         return (ConvertorActionFromOFJava<FROM, PATH>) registryActionFromOFJAva.get(key);
 193     }
 194
 195     @Override
 196     public ObjectRegistration<ConvertorActionToOFJava<Action, org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.actions.grouping.Action>>
 197     registerActionConvertor(
 198             TypeVersionKey<? extends Action> key,
 199             ConvertorActionToOFJava<Action, org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.actions.grouping.Action> convertor) {
 200         registryActionToOFJAva.put(key, convertor);
 201         return hireJanitor(key, convertor);
 202     }
 203
 204     @Override
 205     public ObjectRegistration<ConvertorActionFromOFJava<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.actions.grouping.Action, ActionPath>>
 206     registerActionConvertor(
 207             ExperimenterActionSerializerKey key,
 208             ConvertorActionFromOFJava<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.actions.grouping.Action, ActionPath> convertor) {
 209         registryActionFromOFJAva.put(key, convertor);
 210         return hireJanitor(key, convertor);
 211     }
 212
 213     @Override
 214     public ObjectRegistration<ConvertorToOFJava<MatchEntries>> registerMatchConvertor(ConverterExtensionKey<? extends ExtensionKey> key,
 215             ConvertorToOFJava<MatchEntries> convertor) {
 216         registryToOFJAva.put(key, convertor);
 217         return hireJanitor(key, convertor);
 218     }
 219
 220     @Override
 221     public ObjectRegistration<ConvertorFromOFJava<MatchEntries, MatchPath>> registerMatchConvertor(
 222             MatchEntrySerializerKey<? extends OxmClassBase, ? extends MatchField> key,
 223             ConvertorFromOFJava<MatchEntries, MatchPath> convertor) {
 224         registryFromOFJAva.put(key, convertor);
 225         return hireJanitor(key, convertor);
 226     }
 227
 228 }