From aff854a91905a9f520c374f0258a1a7e5c785537 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Mon, 7 Oct 2013 14:11:56 +0200 Subject: [PATCH] BUG-47: separate Handlers into Parsers and Serializers Change-Id: Ibe5b25b1f751dc70fe165f6f518538a0d2da784c Signed-off-by: Robert Varga --- .../pcep/impl/HandlerRegistryImpl.java | 144 +++++++++++------- .../protocol/pcep/spi/HandlerRegistry.java | 24 +-- ...MessageHandler.java => MessageParser.java} | 5 +- .../protocol/pcep/spi/MessageSerializer.java | 16 ++ .../{ObjectHandler.java => ObjectParser.java} | 5 +- .../protocol/pcep/spi/ObjectSerializer.java | 16 ++ .../spi/{TlvHandler.java => TlvParser.java} | 5 +- .../protocol/pcep/spi/TlvSerializer.java | 16 ++ 8 files changed, 159 insertions(+), 72 deletions(-) rename pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/{MessageHandler.java => MessageParser.java} (78%) create mode 100644 pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/MessageSerializer.java rename pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/{ObjectHandler.java => ObjectParser.java} (79%) create mode 100644 pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/ObjectSerializer.java rename pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/{TlvHandler.java => TlvParser.java} (81%) create mode 100644 pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/TlvSerializer.java 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 81636647ae..15b6ace92a 100644 --- 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 msgHandlerInts = new HashMap<>(); - private final Map, MessageHandler> msgHandlerClasses = new HashMap<>(); + private final Map msgParsers = new HashMap<>(); + private final Map, MessageSerializer> msgSerializers = new HashMap<>(); - private final Map objHandlerInts = new HashMap<>(); - private final Map, ObjectHandler> objHandlerClasses = new HashMap<>(); + private final Map objParsers = new HashMap<>(); + private final Map, ObjectSerializer> objSerializers = new HashMap<>(); - private final Map tlvHandlerInts = new HashMap<>(); - private final Map, TlvHandler> tlvHandlerClasses = new HashMap<>(); + private final Map tlvParsers = new HashMap<>(); + private final Map, 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 msgClass) { - msgHandlerInts.remove(msgType); - msgHandlerClasses.remove(msgClass); + private synchronized void unregisterMessageParser(final Integer msgType) { + msgParsers.remove(msgType); } @Override - public synchronized AutoCloseable registerMessageHandler( - final Class 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 msgClass) { + msgSerializers.remove(msgClass); + } + + @Override + public synchronized AutoCloseable registerMessageSerializer(final Class 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 objClass) { - objHandlerInts.remove(key); - objHandlerClasses.remove(objClass); + private synchronized void unregisterObjectParser(final Integer key) { + objParsers.remove(key); } @Override - public synchronized AutoCloseable registerObjectHandler( - final Class 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 objClass) { + objSerializers.remove(objClass); + } + + @Override + public synchronized AutoCloseable registerObjectSerializer(final Class 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 tlvClass) { - tlvHandlerInts.remove(tlvType); - tlvHandlerClasses.remove(tlvClass); + private synchronized void unregisterTlvParser(final int tlvType) { + tlvParsers.remove(tlvType); } @Override - public synchronized AutoCloseable registerTlvHandler(final Class 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 tlvClass) { + tlvSerializers.remove(tlvClass); + } - tlvHandlerInts.put(tlvType, handler); - tlvHandlerClasses.put(tlvClass, handler); + @Override + public synchronized AutoCloseable registerTlvSerializer(final Class 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 7e07eb373b..8e0e3cd005 100644 --- 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 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 objClass, int objectClass, int objectType, ObjectHandler handler); - public ObjectHandler getObjectHandler(int objectClass, int objectType); - public ObjectHandler getObjectHandler(Object object); + public AutoCloseable registerMessageSerializer(Class msgClass, MessageSerializer serializer); + public MessageSerializer getMessageSerializer(Message message); - public AutoCloseable registerTlvHandler(Class 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 objClass, ObjectSerializer serializer); + public ObjectSerializer getObjectSerializer(Object object); + + public AutoCloseable registerTlvParser(int tlvType, TlvParser parser); + public TlvParser getTlvParser(int tlvType); + + public AutoCloseable registerTlvSerializer(Class 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 236d634478..8e28bf7c75 100644 --- 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 index 0000000000..abb98b8555 --- /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 a8f7068038..803cad52ba 100644 --- 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 index 0000000000..afedda0102 --- /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 cde1cc4c29..d6787c947f 100644 --- 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 index 0000000000..5bc46c0dc5 --- /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); +} -- 2.36.6