pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/HandlerRegistryImpl.java

   1 /*
   2  * Copyright (c) 2013 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.protocol.pcep.impl;
   9
  10 import java.util.Map;
  11 import java.util.concurrent.ConcurrentHashMap;
  12
  13 import org.opendaylight.protocol.concepts.AbstractRegistration;
  14 import org.opendaylight.protocol.pcep.spi.HandlerRegistry;
  15 import org.opendaylight.protocol.pcep.spi.MessageParser;
  16 import org.opendaylight.protocol.pcep.spi.MessageSerializer;
  17 import org.opendaylight.protocol.pcep.spi.ObjectParser;
  18 import org.opendaylight.protocol.pcep.spi.ObjectSerializer;
  19 import org.opendaylight.protocol.pcep.spi.TlvParser;
  20 import org.opendaylight.protocol.pcep.spi.TlvSerializer;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
  24
  25 import com.google.common.base.Preconditions;
  26
  27 public class HandlerRegistryImpl implements HandlerRegistry {
  28         public static final HandlerRegistry INSTANCE;
  29
  30         static {
  31                 final HandlerRegistry reg = new HandlerRegistryImpl();
  32
  33                 // FIXME: fill this in
  34
  35                 //              reg.registerMessageHandler(PCEPOpenMessage.class, 1, new PCEPOpenMessageParser());
  36                 //              reg.registerMessageHandler(PCEPNotificationMessage.class, 5, new PCEPNotificationMessageParser());
  37                 //              reg.registerMessageHandler(PCEPKeepAliveMessage.class, 2, new PCEPKeepAliveMessageParser());
  38                 //              reg.registerMessageHandler(PCEPReplyMessage.class, 4, new PCEPReplyMessageParser());
  39                 //              reg.registerMessageHandler(PCEPRequestMessage.class, 3, new PCEPRequestMessageParser());
  40                 //              reg.registerMessageHandler(PCEPErrorMessage.class, 6, new PCEPErrorMessageParser());
  41                 //              reg.registerMessageHandler(PCEPCloseMessage.class, 7, new PCEPCloseMessageParser());
  42                 //              reg.registerMessageHandler(PCEPUpdateRequestMessage.class, 11, new PCEPUpdateRequestMessageParser());
  43                 //              reg.registerMessageHandler(PCEPReportMessage.class, 10, new PCEPReportMessageParser());
  44                 //              reg.registerMessageHandler(PCCreateMessage.class, 12, new PCCreateMessageParser());
  45
  46                 INSTANCE = reg;
  47         }
  48
  49         private final Map<Integer, MessageParser> msgParsers = new ConcurrentHashMap<>();
  50         private final Map<Class<? extends Message>, MessageSerializer> msgSerializers = new ConcurrentHashMap<>();
  51
  52         private final Map<Integer, ObjectParser> objParsers = new ConcurrentHashMap<>();
  53         private final Map<Class<? extends Object>, ObjectSerializer> objSerializers = new ConcurrentHashMap<>();
  54
  55         private final Map<Integer, TlvParser> tlvParsers = new ConcurrentHashMap<>();
  56         private final Map<Class<? extends Tlv>, TlvSerializer> tlvSerializers = new ConcurrentHashMap<>();
  57
  58         private HandlerRegistryImpl() {
  59
  60         }
  61
  62         @Override
  63         public MessageParser getMessageParser(final int messageType) {
  64                 Preconditions.checkArgument(messageType >= 0 && messageType <= 255);
  65                 return msgParsers.get(messageType);
  66         }
  67
  68         @Override
  69         public MessageSerializer getMessageSerializer(final Message message) {
  70                 final Class<? extends Message> c = message.getClass();
  71                 for (Map.Entry<Class<? extends Message>, MessageSerializer> s : msgSerializers.entrySet()) {
  72                         if (s.getKey().isAssignableFrom(c)) {
  73                                 return s.getValue();
  74                         }
  75                 }
  76
  77                 return null;
  78         }
  79
  80         @Override
  81         public synchronized ObjectParser getObjectParser(final int objectClass, final int objectType) {
  82                 Preconditions.checkArgument(objectClass >= 0 && objectClass <= 255);
  83                 Preconditions.checkArgument(objectType >= 0 && objectType <= 15);
  84
  85                 return objParsers.get((objectClass << 4) + objectType);
  86         }
  87
  88         @Override
  89         public ObjectSerializer getObjectSerializer(final Object object) {
  90                 final Class<? extends Object> c = object.getClass();
  91                 for (Map.Entry<Class<? extends Object>, ObjectSerializer> s : objSerializers.entrySet()) {
  92                         if (s.getKey().isAssignableFrom(c)) {
  93                                 return s.getValue();
  94                         }
  95                 }
  96
  97                 return null;
  98         }
  99
 100         @Override
 101         public TlvParser getTlvParser(final int tlvType) {
 102                 Preconditions.checkArgument(tlvType >= 0 && tlvType <= 65535);
 103                 return tlvParsers.get(tlvType);
 104         }
 105
 106         @Override
 107         public TlvSerializer getTlvSerializer(final Tlv tlv) {
 108                 final Class<? extends Tlv> c = tlv.getClass();
 109                 for (Map.Entry<Class<? extends Tlv>, TlvSerializer> s : tlvSerializers.entrySet()) {
 110                         if (s.getKey().isAssignableFrom(c)) {
 111                                 return s.getValue();
 112                         }
 113                 }
 114
 115                 return null;
 116         }
 117
 118         private synchronized void unregisterMessageParser(final Integer msgType) {
 119                 msgParsers.remove(msgType);
 120         }
 121
 122         @Override
 123         public synchronized AutoCloseable registerMessageParser(final int msgType, final MessageParser parser) {
 124                 Preconditions.checkArgument(msgType >= 0 && msgType <= 255);
 125                 Preconditions.checkArgument(!msgParsers.containsKey(msgType), "Message type %s already registered", msgType);
 126                 msgParsers.put(msgType, parser);
 127
 128                 return new AbstractRegistration() {
 129                         @Override
 130                         protected void removeRegistration() {
 131                                 unregisterMessageParser(msgType);
 132                         }
 133                 };
 134         }
 135
 136         private synchronized void unregisterMessageSerializer(final Class<? extends Message> msgClass) {
 137                 msgSerializers.remove(msgClass);
 138         }
 139
 140         @Override
 141         public synchronized AutoCloseable registerMessageSerializer(final Class<? extends Message> msgClass, final MessageSerializer serializer) {
 142                 Preconditions.checkArgument(!msgSerializers.containsKey(msgClass), "Message class %s already registered", msgClass);
 143                 msgSerializers.put(msgClass, serializer);
 144
 145                 return new AbstractRegistration() {
 146                         @Override
 147                         protected void removeRegistration() {
 148                                 unregisterMessageSerializer(msgClass);
 149                         }
 150                 };
 151         }
 152
 153         private synchronized void unregisterObjectParser(final Integer key) {
 154                 objParsers.remove(key);
 155         }
 156
 157         @Override
 158         public synchronized AutoCloseable registerObjectParser(final int objectClass, final int objectType,
 159                         final ObjectParser parser) {
 160                 Preconditions.checkArgument(objectClass >= 0 && objectClass <= 255);
 161                 Preconditions.checkArgument(objectType >= 0 && objectType <= 15);
 162
 163                 final Integer key = (objectClass << 4) + objectType;
 164                 Preconditions.checkArgument(!objParsers.containsKey(key), "Object class %s type %s already registered", objectClass, objectType);
 165                 objParsers.put(key, parser);
 166
 167                 return new AbstractRegistration() {
 168                         @Override
 169                         protected void removeRegistration() {
 170                                 unregisterObjectParser(key);
 171                         }
 172                 };
 173         }
 174
 175         private synchronized void unregisterObjectSerializer(final Class<? extends Object> objClass) {
 176                 objSerializers.remove(objClass);
 177         }
 178
 179         @Override
 180         public synchronized AutoCloseable registerObjectSerializer(final Class<? extends Object> objClass, final ObjectSerializer serializer) {
 181                 Preconditions.checkArgument(!objSerializers.containsKey(objClass), "Object class %s already registered", objClass);
 182                 objSerializers.put(objClass, serializer);
 183
 184                 return new AbstractRegistration() {
 185                         @Override
 186                         protected void removeRegistration() {
 187                                 unregisterObjectSerializer(objClass);
 188                         }
 189                 };
 190         }
 191
 192         private synchronized void unregisterTlvParser(final int tlvType) {
 193                 tlvParsers.remove(tlvType);
 194         }
 195
 196         @Override
 197         public synchronized AutoCloseable registerTlvParser(final int tlvType, final TlvParser parser) {
 198                 Preconditions.checkArgument(tlvType >= 0 && tlvType <= 65535);
 199                 Preconditions.checkArgument(!tlvParsers.containsKey(tlvType), "TLV type %s already registered", tlvType);
 200
 201                 tlvParsers.put(tlvType, parser);
 202
 203                 return new AbstractRegistration() {
 204                         @Override
 205                         protected void removeRegistration() {
 206                                 unregisterTlvParser(tlvType);
 207                         }
 208                 };
 209         }
 210
 211         private synchronized void unregisterTlvSerializer(final Class<? extends Tlv> tlvClass) {
 212                 tlvSerializers.remove(tlvClass);
 213         }
 214
 215         @Override
 216         public synchronized AutoCloseable registerTlvSerializer(final Class<? extends Tlv> tlvClass, final TlvSerializer serializer) {
 217                 Preconditions.checkArgument(!tlvSerializers.containsKey(tlvClass), "TLV class %s already registered", tlvClass);
 218                 tlvSerializers.put(tlvClass, serializer);
 219
 220                 return new AbstractRegistration() {
 221                         @Override
 222                         protected void removeRegistration() {
 223                                 unregisterTlvSerializer(tlvClass);
 224                         }
 225                 };
 226         }
 227 }