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