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