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.MessageHandler;
  16 import org.opendaylight.protocol.pcep.spi.ObjectHandler;
  17 import org.opendaylight.protocol.pcep.spi.TlvHandler;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
  20
  21 import com.google.common.base.Preconditions;
  22
  23 public class HandlerRegistryImpl implements HandlerRegistry {
  24         public static final HandlerRegistry INSTANCE;
  25
  26         static {
  27                 final HandlerRegistry reg = new HandlerRegistryImpl();
  28
  29                 // FIXME: fill this in
  30
  31                 //              reg.registerMessageHandler(PCEPOpenMessage.class, 1, new PCEPOpenMessageParser());
  32                 //              reg.registerMessageHandler(PCEPNotificationMessage.class, 5, new PCEPNotificationMessageParser());
  33                 //              reg.registerMessageHandler(PCEPKeepAliveMessage.class, 2, new PCEPKeepAliveMessageParser());
  34                 //              reg.registerMessageHandler(PCEPReplyMessage.class, 4, new PCEPReplyMessageParser());
  35                 //              reg.registerMessageHandler(PCEPRequestMessage.class, 3, new PCEPRequestMessageParser());
  36                 //              reg.registerMessageHandler(PCEPErrorMessage.class, 6, new PCEPErrorMessageParser());
  37                 //              reg.registerMessageHandler(PCEPCloseMessage.class, 7, new PCEPCloseMessageParser());
  38                 //              reg.registerMessageHandler(PCEPUpdateRequestMessage.class, 11, new PCEPUpdateRequestMessageParser());
  39                 //              reg.registerMessageHandler(PCEPReportMessage.class, 10, new PCEPReportMessageParser());
  40                 //              reg.registerMessageHandler(PCCreateMessage.class, 12, new PCCreateMessageParser());
  41
  42                 INSTANCE = reg;
  43         }
  44
  45         private final Map<Integer, MessageHandler> msgHandlerInts = new HashMap<>();
  46         private final Map<Class<? extends Message>, MessageHandler> msgHandlerClasses = new HashMap<>();
  47
  48         private final Map<Integer, ObjectHandler> objHandlerInts = new HashMap<>();
  49         private final Map<Class<? extends Object>, ObjectHandler> objHandlerClasses = new HashMap<>();
  50
  51         private final Map<Integer, TlvHandler> tlvHandlerInts = new HashMap<>();
  52         private final Map<Class<? extends Tlv>, TlvHandler> tlvHandlerClasses = new HashMap<>();
  53
  54         private HandlerRegistryImpl() {
  55
  56         }
  57
  58         @Override
  59         public synchronized MessageHandler getMessageHandler(final int messageType) {
  60                 Preconditions.checkArgument(messageType >= 0 && messageType <= 255);
  61                 return msgHandlerInts.get(messageType);
  62         }
  63
  64         @Override
  65         public synchronized MessageHandler getMessageHandler(final Message message) {
  66                 return msgHandlerClasses.get(message.getClass());
  67         }
  68
  69         @Override
  70         public synchronized ObjectHandler getObjectHandler(final int objectClass, final int objectType) {
  71                 Preconditions.checkArgument(objectClass >= 0 && objectClass <= 255);
  72                 Preconditions.checkArgument(objectType >= 0 && objectType <= 15);
  73
  74                 return objHandlerInts.get((objectClass << 4) + objectType);
  75         }
  76
  77         @Override
  78         public synchronized ObjectHandler getObjectHandler(final Object object) {
  79                 return objHandlerClasses.get(object.getClass());
  80         }
  81
  82         @Override
  83         public synchronized TlvHandler getTlvHandler(final int tlvType) {
  84                 Preconditions.checkArgument(tlvType >= 0 && tlvType <= 65535);
  85                 return tlvHandlerInts.get(tlvType);
  86         }
  87
  88         @Override
  89         public synchronized TlvHandler getTlvHandler(final Tlv tlv) {
  90                 return tlvHandlerClasses.get(tlv.getClass());
  91         }
  92
  93         private synchronized void unregisterMessageHandler(final Integer msgType, final Class<? extends Message> msgClass) {
  94                 msgHandlerInts.remove(msgType);
  95                 msgHandlerClasses.remove(msgClass);
  96         }
  97
  98         @Override
  99         public synchronized AutoCloseable registerMessageHandler(
 100                         final Class<? extends Message> msgClass, final int msgType,
 101                         final MessageHandler handler) {
 102                 Preconditions.checkArgument(msgType >= 0 && msgType <= 255);
 103
 104                 Preconditions.checkArgument(!msgHandlerInts.containsKey(msgType), "Message type %s already registered", msgType);
 105                 Preconditions.checkArgument(!msgHandlerClasses.containsKey(msgClass), "Message class %s already registered", msgClass);
 106
 107                 msgHandlerInts.put(msgType, handler);
 108                 msgHandlerClasses.put(msgClass, handler);
 109
 110                 return new AbstractRegistration() {
 111                         @Override
 112                         protected void removeRegistration() {
 113                                 unregisterMessageHandler(msgType, msgClass);
 114                         }
 115                 };
 116         }
 117
 118         private synchronized void unregisterObjectHandler(final Integer key, final Class<? extends Object> objClass) {
 119                 objHandlerInts.remove(key);
 120                 objHandlerClasses.remove(objClass);
 121         }
 122
 123         @Override
 124         public synchronized AutoCloseable registerObjectHandler(
 125                         final Class<? extends Object> objClass, final int objectClass, final int objectType,
 126                         final ObjectHandler handler) {
 127                 Preconditions.checkArgument(objectClass >= 0 && objectClass <= 255);
 128                 Preconditions.checkArgument(objectType >= 0 && objectType <= 15);
 129
 130                 final Integer key = (objectClass << 4) + objectType;
 131                 Preconditions.checkArgument(!objHandlerInts.containsKey(key), "Object class %s type %s already registered",
 132                                 objectClass, objectType);
 133                 Preconditions.checkArgument(!objHandlerClasses.containsKey(objectClass), "TLV class %s already registered", objectClass);
 134
 135                 objHandlerInts.put(key, handler);
 136                 objHandlerClasses.put(objClass, handler);
 137
 138                 return new AbstractRegistration() {
 139                         @Override
 140                         protected void removeRegistration() {
 141                                 unregisterObjectHandler(key, objClass);
 142                         }
 143                 };
 144         }
 145
 146         private synchronized void unregisterTlvHandler(final int tlvType, final Class<? extends Tlv> tlvClass) {
 147                 tlvHandlerInts.remove(tlvType);
 148                 tlvHandlerClasses.remove(tlvClass);
 149         }
 150
 151         @Override
 152         public synchronized AutoCloseable registerTlvHandler(final Class<? extends Tlv> tlvClass,
 153                         final int tlvType, final TlvHandler handler) {
 154                 Preconditions.checkArgument(tlvType >= 0 && tlvType <= 65535);
 155
 156                 Preconditions.checkArgument(!tlvHandlerInts.containsKey(tlvType), "TLV type %s already registered", tlvType);
 157                 Preconditions.checkArgument(!tlvHandlerClasses.containsKey(tlvClass), "TLV class %s already registered", tlvClass);
 158
 159                 tlvHandlerInts.put(tlvType, handler);
 160                 tlvHandlerClasses.put(tlvClass, handler);
 161
 162                 return new AbstractRegistration() {
 163                         @Override
 164                         protected void removeRegistration() {
 165                                 unregisterTlvHandler(tlvType, tlvClass);
 166                         }
 167                 };
 168         }
 169 }