BUG-47: separate Handlers into Parsers and Serializers

Change-Id: Ibe5b25b1f751dc70fe165f6f518538a0d2da784c
Signed-off-by: Robert Varga <rovarga@cisco.com>

diff --git a/pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/HandlerRegistryImpl.java b/pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/HandlerRegistryImpl.java
index 81636647ae1ba0001befb6fbfc76ded48eafefa7..15b6ace92aea10e7c7676dda32e10f202fc6509f 100644 (file)
--- a/pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/HandlerRegistryImpl.java
+++ b/pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/HandlerRegistryImpl.java
@@ -12,9 +12,12 @@ import java.util.Map;
 
 import org.opendaylight.protocol.concepts.AbstractRegistration;
 import org.opendaylight.protocol.pcep.spi.HandlerRegistry;
-import org.opendaylight.protocol.pcep.spi.MessageHandler;
-import org.opendaylight.protocol.pcep.spi.ObjectHandler;
-import org.opendaylight.protocol.pcep.spi.TlvHandler;
+import org.opendaylight.protocol.pcep.spi.MessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageSerializer;
+import org.opendaylight.protocol.pcep.spi.ObjectParser;
+import org.opendaylight.protocol.pcep.spi.ObjectSerializer;
+import org.opendaylight.protocol.pcep.spi.TlvParser;
+import org.opendaylight.protocol.pcep.spi.TlvSerializer;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
 
@@ -42,127 +45,160 @@ public class HandlerRegistryImpl implements HandlerRegistry {
                INSTANCE = reg;
        }
 
-       private final Map<Integer, MessageHandler> msgHandlerInts = new HashMap<>();
-       private final Map<Class<? extends Message>, MessageHandler> msgHandlerClasses = new HashMap<>();
+       private final Map<Integer, MessageParser> msgParsers = new HashMap<>();
+       private final Map<Class<? extends Message>, MessageSerializer> msgSerializers = new HashMap<>();
 
-       private final Map<Integer, ObjectHandler> objHandlerInts = new HashMap<>();
-       private final Map<Class<? extends Object>, ObjectHandler> objHandlerClasses = new HashMap<>();
+       private final Map<Integer, ObjectParser> objParsers = new HashMap<>();
+       private final Map<Class<? extends Object>, ObjectSerializer> objSerializers = new HashMap<>();
 
-       private final Map<Integer, TlvHandler> tlvHandlerInts = new HashMap<>();
-       private final Map<Class<? extends Tlv>, TlvHandler> tlvHandlerClasses = new HashMap<>();
+       private final Map<Integer, TlvParser> tlvParsers = new HashMap<>();
+       private final Map<Class<? extends Tlv>, TlvSerializer> tlvSerializers = new HashMap<>();
 
        private HandlerRegistryImpl() {
 
        }
 
        @Override
-       public synchronized MessageHandler getMessageHandler(final int messageType) {
+       public synchronized MessageParser getMessageParser(final int messageType) {
                Preconditions.checkArgument(messageType >= 0 && messageType <= 255);
-               return msgHandlerInts.get(messageType);
+               return msgParsers.get(messageType);
        }
 
        @Override
-       public synchronized MessageHandler getMessageHandler(final Message message) {
-               return msgHandlerClasses.get(message.getClass());
+       public synchronized MessageSerializer getMessageSerializer(final Message message) {
+               return msgSerializers.get(message.getClass());
        }
 
        @Override
-       public synchronized ObjectHandler getObjectHandler(final int objectClass, final int objectType) {
+       public synchronized ObjectParser getObjectParser(final int objectClass, final int objectType) {
                Preconditions.checkArgument(objectClass >= 0 && objectClass <= 255);
                Preconditions.checkArgument(objectType >= 0 && objectType <= 15);
 
-               return objHandlerInts.get((objectClass << 4) + objectType);
+               return objParsers.get((objectClass << 4) + objectType);
        }
 
        @Override
-       public synchronized ObjectHandler getObjectHandler(final Object object) {
-               return objHandlerClasses.get(object.getClass());
+       public synchronized ObjectSerializer getObjectSerializer(final Object object) {
+               return objSerializers.get(object.getClass());
        }
 
        @Override
-       public synchronized TlvHandler getTlvHandler(final int tlvType) {
+       public synchronized TlvParser getTlvParser(final int tlvType) {
                Preconditions.checkArgument(tlvType >= 0 && tlvType <= 65535);
-               return tlvHandlerInts.get(tlvType);
+               return tlvParsers.get(tlvType);
        }
 
        @Override
-       public synchronized TlvHandler getTlvHandler(final Tlv tlv) {
-               return tlvHandlerClasses.get(tlv.getClass());
+       public synchronized TlvSerializer getTlvSerializer(final Tlv tlv) {
+               return tlvSerializers.get(tlv.getClass());
        }
 
-       private synchronized void unregisterMessageHandler(final Integer msgType, final Class<? extends Message> msgClass) {
-               msgHandlerInts.remove(msgType);
-               msgHandlerClasses.remove(msgClass);
+       private synchronized void unregisterMessageParser(final Integer msgType) {
+               msgParsers.remove(msgType);
        }
 
        @Override
-       public synchronized AutoCloseable registerMessageHandler(
-                       final Class<? extends Message> msgClass, final int msgType,
-                       final MessageHandler handler) {
+       public synchronized AutoCloseable registerMessageParser(final int msgType, final MessageParser parser) {
                Preconditions.checkArgument(msgType >= 0 && msgType <= 255);
+               Preconditions.checkArgument(!msgParsers.containsKey(msgType), "Message type %s already registered", msgType);
+               msgParsers.put(msgType, parser);
 
-               Preconditions.checkArgument(!msgHandlerInts.containsKey(msgType), "Message type %s already registered", msgType);
-               Preconditions.checkArgument(!msgHandlerClasses.containsKey(msgClass), "Message class %s already registered", msgClass);
+               return new AbstractRegistration() {
+                       @Override
+                       protected void removeRegistration() {
+                               unregisterMessageParser(msgType);
+                       }
+               };
+       }
 
-               msgHandlerInts.put(msgType, handler);
-               msgHandlerClasses.put(msgClass, handler);
+       private synchronized void unregisterMessageSerializer(final Class<? extends Message> msgClass) {
+               msgSerializers.remove(msgClass);
+       }
+
+       @Override
+       public synchronized AutoCloseable registerMessageSerializer(final Class<? extends Message> msgClass, final MessageSerializer serializer) {
+               Preconditions.checkArgument(!msgSerializers.containsKey(msgClass), "Message class %s already registered", msgClass);
+               msgSerializers.put(msgClass, serializer);
 
                return new AbstractRegistration() {
                        @Override
                        protected void removeRegistration() {
-                               unregisterMessageHandler(msgType, msgClass);
+                               unregisterMessageSerializer(msgClass);
                        }
                };
        }
 
-       private synchronized void unregisterObjectHandler(final Integer key, final Class<? extends Object> objClass) {
-               objHandlerInts.remove(key);
-               objHandlerClasses.remove(objClass);
+       private synchronized void unregisterObjectParser(final Integer key) {
+               objParsers.remove(key);
        }
 
        @Override
-       public synchronized AutoCloseable registerObjectHandler(
-                       final Class<? extends Object> objClass, final int objectClass, final int objectType,
-                       final ObjectHandler handler) {
+       public synchronized AutoCloseable registerObjectParser(final int objectClass, final int objectType,
+                       final ObjectParser parser) {
                Preconditions.checkArgument(objectClass >= 0 && objectClass <= 255);
                Preconditions.checkArgument(objectType >= 0 && objectType <= 15);
 
                final Integer key = (objectClass << 4) + objectType;
-               Preconditions.checkArgument(!objHandlerInts.containsKey(key), "Object class %s type %s already registered",
-                               objectClass, objectType);
-               Preconditions.checkArgument(!objHandlerClasses.containsKey(objectClass), "TLV class %s already registered", objectClass);
+               Preconditions.checkArgument(!objParsers.containsKey(key), "Object class %s type %s already registered", objectClass, objectType);
+               objParsers.put(key, parser);
 
-               objHandlerInts.put(key, handler);
-               objHandlerClasses.put(objClass, handler);
+               return new AbstractRegistration() {
+                       @Override
+                       protected void removeRegistration() {
+                               unregisterObjectParser(key);
+                       }
+               };
+       }
+
+       private synchronized void unregisterObjectSerializer(final Class<? extends Object> objClass) {
+               objSerializers.remove(objClass);
+       }
+
+       @Override
+       public synchronized AutoCloseable registerObjectSerializer(final Class<? extends Object> objClass, final ObjectSerializer serializer) {
+               Preconditions.checkArgument(!objSerializers.containsKey(objClass), "Object class %s already registered", objClass);
+               objSerializers.put(objClass, serializer);
 
                return new AbstractRegistration() {
                        @Override
                        protected void removeRegistration() {
-                               unregisterObjectHandler(key, objClass);
+                               unregisterObjectSerializer(objClass);
                        }
                };
        }
 
-       private synchronized void unregisterTlvHandler(final int tlvType, final Class<? extends Tlv> tlvClass) {
-               tlvHandlerInts.remove(tlvType);
-               tlvHandlerClasses.remove(tlvClass);
+       private synchronized void unregisterTlvParser(final int tlvType) {
+               tlvParsers.remove(tlvType);
        }
 
        @Override
-       public synchronized AutoCloseable registerTlvHandler(final Class<? extends Tlv> tlvClass,
-                       final int tlvType, final TlvHandler handler) {
+       public synchronized AutoCloseable registerTlvParser(final int tlvType, final TlvParser parser) {
                Preconditions.checkArgument(tlvType >= 0 && tlvType <= 65535);
+               Preconditions.checkArgument(!tlvParsers.containsKey(tlvType), "TLV type %s already registered", tlvType);
+
+               tlvParsers.put(tlvType, parser);
+
+               return new AbstractRegistration() {
+                       @Override
+                       protected void removeRegistration() {
+                               unregisterTlvParser(tlvType);
+                       }
+               };
+       }
 
-               Preconditions.checkArgument(!tlvHandlerInts.containsKey(tlvType), "TLV type %s already registered", tlvType);
-               Preconditions.checkArgument(!tlvHandlerClasses.containsKey(tlvClass), "TLV class %s already registered", tlvClass);
+       private synchronized void unregisterTlvSerializer(final Class<? extends Tlv> tlvClass) {
+               tlvSerializers.remove(tlvClass);
+       }
 
-               tlvHandlerInts.put(tlvType, handler);
-               tlvHandlerClasses.put(tlvClass, handler);
+       @Override
+       public synchronized AutoCloseable registerTlvSerializer(final Class<? extends Tlv> tlvClass, final TlvSerializer serializer) {
+               Preconditions.checkArgument(!tlvSerializers.containsKey(tlvClass), "TLV class %s already registered", tlvClass);
+               tlvSerializers.put(tlvClass, serializer);
 
                return new AbstractRegistration() {
                        @Override
                        protected void removeRegistration() {
-                               unregisterTlvHandler(tlvType, tlvClass);
+                               unregisterTlvSerializer(tlvClass);
                        }
                };
        }

diff --git a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/HandlerRegistry.java b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/HandlerRegistry.java
index 7e07eb373b509ad11234d562185867d107c36213..8e0e3cd005add5f1e6f6d02f04cc89d918cf0a8d 100644 (file)
--- a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/HandlerRegistry.java
+++ b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/HandlerRegistry.java
@@ -11,15 +11,21 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.typ
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
 
 public interface HandlerRegistry {
-       public AutoCloseable registerMessageHandler(Class<? extends Message> msgClass, int messageType, MessageHandler handler);
-       public MessageHandler getMessageHandler(int messageType);
-       public MessageHandler getMessageHandler(Message message);
+       public AutoCloseable registerMessageParser(int messageType, MessageParser parser);
+       public MessageParser getMessageParser(int messageType);
 
-       public AutoCloseable registerObjectHandler(Class<? extends Object> objClass, int objectClass, int objectType, ObjectHandler handler);
-       public ObjectHandler getObjectHandler(int objectClass, int objectType);
-       public ObjectHandler getObjectHandler(Object object);
+       public AutoCloseable registerMessageSerializer(Class<? extends Message> msgClass, MessageSerializer serializer);
+       public MessageSerializer getMessageSerializer(Message message);
 
-       public AutoCloseable registerTlvHandler(Class<? extends Tlv> tlvClass, int tlvType, TlvHandler handler);
-       public TlvHandler getTlvHandler(int tlvType);
-       public TlvHandler getTlvHandler(Tlv tlv);
+       public AutoCloseable registerObjectParser(int objectClass, int objectType, ObjectParser parser);
+       public ObjectParser getObjectParser(int objectClass, int objectType);
+
+       public AutoCloseable registerObjectSerializer(Class<? extends Object> objClass, ObjectSerializer serializer);
+       public ObjectSerializer getObjectSerializer(Object object);
+
+       public AutoCloseable registerTlvParser(int tlvType, TlvParser parser);
+       public TlvParser getTlvParser(int tlvType);
+
+       public AutoCloseable registerTlvSerializer(Class<? extends Tlv> tlvClass, TlvSerializer serializer);
+       public TlvSerializer getTlvSerializer(Tlv tlv);
 }

diff --git a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageHandler.java b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageParser.java
similarity index 78%
rename from pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageHandler.java
rename to pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageParser.java
index 236d634478a703f1f9fd29fd19ccd8654d205e4c..8e28bf7c7556f911e4bb387758249c8a649fbeba 100644 (file)
--- a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageHandler.java
+++ b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageParser.java
@@ -11,7 +11,6 @@ import io.netty.buffer.ByteBuf;
 
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
 
-public interface MessageHandler {
-       public Message messageFromBytes(ByteBuf bytes);
-       public ByteBuf bytesFromMessage(Message message);
+public interface MessageParser {
+       public Message parseMessage(ByteBuf buffer);
 }

diff --git a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageSerializer.java b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageSerializer.java
new file mode 100644 (file)
index 0000000..abb98b8
--- /dev/null
+++ b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageSerializer.java
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.pcep.spi;
+
+import io.netty.buffer.ByteBuf;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
+
+public interface MessageSerializer {
+       public void serializeMessage(Message message, ByteBuf buffer);
+}

diff --git a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectHandler.java b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectParser.java
similarity index 79%
rename from pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectHandler.java
rename to pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectParser.java
index a8f706803874f4213fa853be464bf06fe112eaa3..803cad52babc9053fc890ff19c61daad01d636b2 100644 (file)
--- a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectHandler.java
+++ b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectParser.java
@@ -11,7 +11,6 @@ import io.netty.buffer.ByteBuf;
 
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
 
-public interface ObjectHandler {
-       public Object objectFromBytes(ByteBuf bytes);
-       public ByteBuf bytesFromObject(Object object);
+public interface ObjectParser {
+       public Object parseObject(ByteBuf buffer);
 }

diff --git a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectSerializer.java b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectSerializer.java
new file mode 100644 (file)
index 0000000..afedda0
--- /dev/null
+++ b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectSerializer.java
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.pcep.spi;
+
+import io.netty.buffer.ByteBuf;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
+
+public interface ObjectSerializer {
+       public ByteBuf serializeObject(Object object, ByteBuf buffer);
+}

diff --git a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvHandler.java b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvParser.java
similarity index 81%
rename from pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvHandler.java
rename to pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvParser.java
index cde1cc4c2924885f3e7791d13923438450b97230..d6787c947fb0a2345f158b36cd35ae9a3ec4444f 100644 (file)
--- a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvHandler.java
+++ b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvParser.java
@@ -11,7 +11,6 @@ import io.netty.buffer.ByteBuf;
 
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
 
-public interface TlvHandler {
-       public Tlv tlvFromBytes(ByteBuf bytes);
-       public ByteBuf bytesFromTlv(Tlv tlv);
+public interface TlvParser {
+       public Tlv parseTlv(ByteBuf buffer);
 }

diff --git a/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvSerializer.java b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvSerializer.java
new file mode 100644 (file)
index 0000000..5bc46c0
--- /dev/null
+++ b/pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvSerializer.java
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.pcep.spi;
+
+import io.netty.buffer.ByteBuf;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
+
+public interface TlvSerializer {
+       public void serializeTlv(Tlv tlv, ByteBuf buffer);
+}