diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFMessageReader.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFMessageReader.java
index 8837867..ca28daf 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFMessageReader.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFMessageReader.java
@@ -1,8 +1,8 @@
 package org.projectfloodlight.openflow.protocol;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 public interface OFMessageReader<T> {
-    T readFrom(ChannelBuffer bb) throws OFParseError;
+    T readFrom(ByteBuf bb) throws OFParseError;
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFMessageWriter.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFMessageWriter.java
index bec5634..5890ce3 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFMessageWriter.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFMessageWriter.java
@@ -1,8 +1,8 @@
 package org.projectfloodlight.openflow.protocol;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 public interface OFMessageWriter<T> {
-    public void write(ChannelBuffer bb, T message) throws OFParseError;
+    public void write(ByteBuf bb, T message) throws OFParseError;
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFObjectFactory.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFObjectFactory.java
index c5869ef..a829b22 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFObjectFactory.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFObjectFactory.java
@@ -1,7 +1,7 @@
 package org.projectfloodlight.openflow.protocol;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 public interface OFObjectFactory<T extends OFObject> {
-    T read(ChannelBuffer buffer);
+    T read(ByteBuf buffer);
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFOxmList.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFOxmList.java
index 7f66110..5b13da8 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFOxmList.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFOxmList.java
@@ -4,7 +4,7 @@
 import java.util.Iterator;
 import java.util.Map;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.match.MatchField;
 import org.projectfloodlight.openflow.protocol.match.MatchFields;
@@ -97,13 +97,13 @@
         return new OFOxmList(map);
     }
 
-    public static OFOxmList readFrom(ChannelBuffer bb, int length,
+    public static OFOxmList readFrom(ByteBuf bb, int length,
             OFMessageReader<OFOxm<?>> reader) throws OFParseError {
         return ofList(ChannelUtils.readList(bb, length, reader));
     }
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         for (OFOxm<?> o : this) {
             o.writeTo(bb);
         }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFOxsList.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFOxsList.java
new file mode 100644
index 0000000..1111088
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFOxsList.java
@@ -0,0 +1,140 @@
+package org.projectfloodlight.openflow.protocol;
+
+import java.util.EnumMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.projectfloodlight.openflow.exceptions.OFParseError;
+import org.projectfloodlight.openflow.protocol.oxs.OFOxs;
+import org.projectfloodlight.openflow.protocol.stat.StatField;
+import org.projectfloodlight.openflow.protocol.stat.StatFields;
+import org.projectfloodlight.openflow.types.OFValueType;
+import org.projectfloodlight.openflow.types.PrimitiveSinkable;
+import org.projectfloodlight.openflow.util.ChannelUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.hash.PrimitiveSink;
+
+import io.netty.buffer.ByteBuf;
+
+
+public class OFOxsList implements Iterable<OFOxs<?>>, Writeable, PrimitiveSinkable {
+    private static final Logger logger = LoggerFactory.getLogger(OFOxsList.class);
+
+    private final Map<StatFields, OFOxs<?>> oxsMap;
+
+    public final static OFOxsList EMPTY = new OFOxsList(ImmutableMap.<StatFields, OFOxs<?>>of());
+
+    private OFOxsList(Map<StatFields, OFOxs<?>> oxsMap) {
+        this.oxsMap = oxsMap;
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends OFValueType<T>> OFOxs<T> get(StatField<T> statField) {
+        return (OFOxs<T>) oxsMap.get(statField.id);
+    }
+
+    public static class Builder {
+        private final Map<StatFields, OFOxs<?>> oxsMap;
+
+        public Builder() {
+            oxsMap = new EnumMap<StatFields, OFOxs<?>>(StatFields.class);
+        }
+
+        public Builder(EnumMap<StatFields, OFOxs<?>> oxsMap) {
+            this.oxsMap = oxsMap;
+        }
+
+        public <T extends OFValueType<T>> void set(OFOxs<T> oxs) {
+            oxsMap.put(oxs.getStatField().id, oxs);
+        }
+
+        public <T extends OFValueType<T>> void unset(StatField<T> statField) {
+            oxsMap.remove(statField.id);
+        }
+
+        public OFOxsList build() {
+            return OFOxsList.ofList(oxsMap.values());
+        }
+    }
+
+    @Override
+    public Iterator<OFOxs<?>> iterator() {
+        return oxsMap.values().iterator();
+    }
+
+    public static OFOxsList ofList(Iterable<OFOxs<?>> oxsList) {
+        Map<StatFields, OFOxs<?>> map = new EnumMap<StatFields, OFOxs<?>>(
+                StatFields.class);
+        for (OFOxs<?> o : oxsList) {
+            map.put(o.getStatField().id, o);
+        }
+        return new OFOxsList(map);
+    }
+
+    public static OFOxsList of(OFOxs<?>... oxss) {
+        Map<StatFields, OFOxs<?>> map = new EnumMap<StatFields, OFOxs<?>>(
+                StatFields.class);
+        for (OFOxs<?> o : oxss) {
+            map.put(o.getStatField().id, o);
+        }
+        return new OFOxsList(map);
+    }
+
+    public static OFOxsList readFrom(ByteBuf bb, int length,
+            OFMessageReader<OFOxs<?>> reader) throws OFParseError {
+        return ofList(ChannelUtils.readList(bb, length, reader));
+    }
+
+    @Override
+    public void writeTo(ByteBuf bb) {
+        for (OFOxs<?> o : this) {
+            o.writeTo(bb);
+        }
+    }
+
+    public OFOxsList.Builder createBuilder() {
+        return new OFOxsList.Builder(new EnumMap<StatFields, OFOxs<?>>(oxsMap));
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((oxsMap == null) ? 0 : oxsMap.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        OFOxsList other = (OFOxsList) obj;
+        if (oxsMap == null) {
+            if (other.oxsMap != null)
+                return false;
+        } else if (!oxsMap.equals(other.oxsMap))
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "OFOxsList" + oxsMap;
+    }
+
+    @Override
+    public void putTo(PrimitiveSink sink) {
+        for (OFOxs<?> o : this) {
+            o.putTo(sink);
+        }
+    }
+
+
+}
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFVersion.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFVersion.java
index 0c54fdc..ccb7f68 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFVersion.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/OFVersion.java
@@ -1,7 +1,7 @@
 package org.projectfloodlight.openflow.protocol;
 
 public enum OFVersion {
-    OF_10(1), OF_11(2), OF_12(3), OF_13(4), OF_14(5);
+    OF_10(1), OF_11(2), OF_12(3), OF_13(4), OF_14(5), OF_15(6);
 
     public final int wireVersion;
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/Writeable.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/Writeable.java
index 31ae9ab..32aaf2b 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/Writeable.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/Writeable.java
@@ -1,7 +1,7 @@
 package org.projectfloodlight.openflow.protocol;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 public interface Writeable {
-    void writeTo(ChannelBuffer bb);
+    void writeTo(ByteBuf bb);
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/Match.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/Match.java
index 67513b9..fdd1ca7 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/Match.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/Match.java
@@ -56,6 +56,7 @@
      * </ul>
      * If one of the above conditions does not hold, returns null. Value is returned masked if partially wildcarded.
      *
+     * @param <F> MatchField type
      * @param field Match field to retrieve
      * @return Value of match field (may be masked), or <code>null</code> if field is one of the conditions above does not hold.
      * @throws UnsupportedOperationException If field is not supported.
@@ -67,6 +68,7 @@
      * Prerequisite: field is partially masked.
      * If prerequisite is not met, a <code>null</code> is returned.
      *
+     * @param <F> MatchField type
      * @param field Match field to retrieve.
      * @return Masked value of match field or null if no mask is set.
      * @throws UnsupportedOperationException If field is not supported.
@@ -128,7 +130,7 @@
      * match. This includes the match fields that are exact or masked match
      * (but not fully wildcarded).
      *
-     * @return
+     * @return the Iterable of MatchField
      */
     public Iterable<MatchField<?>> getMatchFields();
 
@@ -169,6 +171,7 @@
         /**
          * Sets a specific exact value for a field.
          *
+         * @param <F> MatchField and value type
          * @param field Match field to set.
          * @param value Value of match field.
          * @return the Builder instance used.
@@ -179,6 +182,7 @@
         /**
          * Sets a masked value for a field.
          *
+         * @param <F> MatchField, value, and mask type
          * @param field Match field to set.
          * @param value Value of field.
          * @param mask Mask value.
@@ -190,6 +194,7 @@
         /**
          * Sets a masked value for a field.
          *
+         * @param <F> MatchField and value with mask type
          * @param field Match field to set.
          * @param valueWithMask Compound Masked object contains the value and the mask.
          * @return the Builder instance used.
@@ -200,6 +205,7 @@
         /**
          * Unsets any value given for the field and wildcards it so that it matches any value.
          *
+         * @param <F> MatchField type
          * @param field Match field to unset.
          * @return the Builder instance used.
          * @throws UnsupportedOperationException If field is not supported.
@@ -213,4 +219,4 @@
          */
         public Match build();
     }
-}
\ No newline at end of file
+}
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/MatchField.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/MatchField.java
index 48f38d7..33a6736 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/MatchField.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/MatchField.java
@@ -21,6 +21,7 @@
 import org.projectfloodlight.openflow.types.OFValueType;
 import org.projectfloodlight.openflow.types.OFVlanVidMatch;
 import org.projectfloodlight.openflow.types.TransportPort;
+import org.projectfloodlight.openflow.types.PacketType;
 import org.projectfloodlight.openflow.types.U16;
 import org.projectfloodlight.openflow.types.U32;
 import org.projectfloodlight.openflow.types.U64;
@@ -30,16 +31,22 @@
 import org.projectfloodlight.openflow.types.VlanPcp;
 import org.projectfloodlight.openflow.types.CircuitSignalID;
 import org.projectfloodlight.openflow.types.OduSignalID;
+import org.projectfloodlight.openflow.types.VxlanNI;
+import org.projectfloodlight.openflow.types.VFI;
+
+import java.util.Set;
+import com.google.common.collect.ImmutableSet;
 
 public class MatchField<F extends OFValueType<F>> {
     private final String name;
     public final MatchFields id;
-    private final Prerequisite<?>[] prerequisites;
+    private final Set<Prerequisite<?>> prerequisites;
 
     private MatchField(final String name, final MatchFields id, Prerequisite<?>... prerequisites) {
         this.name = name;
         this.id = id;
-        this.prerequisites = prerequisites;
+        /* guaranteed non-null (private constructor); 'null' isn't passed as prerequisites */
+        this.prerequisites = ImmutableSet.copyOf(prerequisites);
     }
 
     public final static MatchField<OFPort> IN_PORT =
@@ -197,10 +204,26 @@
             new MatchField<U64>("tunnel_id", MatchFields.TUNNEL_ID);
 
     public final static MatchField<U16> IPV6_EXTHDR =
-            new MatchField<U16>("ipv6_exthdr", MatchFields.IPV6_EXTHDR);
+            new MatchField<U16>("ipv6_exthdr", MatchFields.IPV6_EXTHDR,
+                    new Prerequisite<EthType>(MatchField.ETH_TYPE, EthType.IPv6));
 
     public final static MatchField<OFBooleanValue> PBB_UCA =
-            new MatchField<OFBooleanValue>("pbb_uca", MatchFields.PBB_UCA);
+            new MatchField<OFBooleanValue>("pbb_uca", MatchFields.PBB_UCA,
+                    new Prerequisite<EthType>(MatchField.ETH_TYPE, EthType.PBB));
+
+    public final static MatchField<U16> TCP_FLAGS =
+            new MatchField<U16>("tcp_flags", MatchFields.TCP_FLAGS,
+                    new Prerequisite<IpProtocol>(MatchField.IP_PROTO, IpProtocol.TCP));
+
+    public final static MatchField<U16> OVS_TCP_FLAGS =
+            new MatchField<U16>("ovs_tcp_flags", MatchFields.OVS_TCP_FLAGS,
+                    new Prerequisite<IpProtocol>(MatchField.IP_PROTO, IpProtocol.TCP));
+
+    public final static MatchField<PacketType> PACKET_TYPE =
+            new MatchField<PacketType>("packet_type", MatchFields.PACKET_TYPE);
+
+    public final static MatchField<OFPort> ACTSET_OUTPUT =
+            new MatchField<OFPort>("actset_output", MatchFields.ACTSET_OUTPUT);
 
     public final static MatchField<IPv4Address> TUNNEL_IPV4_SRC =
             new MatchField<IPv4Address>("tunnel_ipv4_src", MatchFields.TUNNEL_IPV4_SRC,
@@ -297,8 +320,8 @@
     public final static MatchField<OFBooleanValue> BSN_L2_CACHE_HIT =
             new MatchField<OFBooleanValue>("bsn_l2_cache_hit", MatchFields.BSN_L2_CACHE_HIT);
 
-    public final static MatchField<U32> BSN_VXLAN_NETWORK_ID =
-            new MatchField<U32>("bsn_vxlan_network_id", MatchFields.BSN_VXLAN_NETWORK_ID);
+    public final static MatchField<VxlanNI> BSN_VXLAN_NETWORK_ID =
+            new MatchField<VxlanNI>("bsn_vxlan_network_id", MatchFields.BSN_VXLAN_NETWORK_ID);
 
     public final static MatchField<MacAddress> BSN_INNER_ETH_DST =
             new MatchField<MacAddress>("bsn_inner_eth_dst", MatchFields.BSN_INNER_ETH_DST);
@@ -406,6 +429,13 @@
             new MatchField<U16>("ofdpa_ovid", MatchFields.OFDPA_OVID,
                 new Prerequisite<OFVlanVidMatch>(MatchField.VLAN_VID));
 
+    public final static MatchField<VFI> BSN_VFI =
+            new MatchField<VFI>("bsn_vfi", MatchFields.BSN_VFI);
+
+    public final static MatchField<OFBooleanValue> BSN_IP_FRAGMENTATION =
+            new MatchField<OFBooleanValue>("bsn_ip_fragmentation", MatchFields.BSN_IP_FRAGMENTATION,
+                    new Prerequisite<EthType>(MatchField.ETH_TYPE, EthType.IPv4, EthType.IPv6));
+
     public String getName() {
         return name;
     }
@@ -419,4 +449,15 @@
         return true;
     }
 
+    /**
+     * Retrieve what also must be matched in order to
+     * use this particular MatchField.
+     *
+     * @return unmodifiable view of the prerequisites
+     */
+    public Set<Prerequisite<?>> getPrerequisites() {
+        /* assumes non-null; guaranteed by constructor */
+        return this.prerequisites;
+    }
+
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/MatchFields.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/MatchFields.java
index 9274153..3f86466 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/MatchFields.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/MatchFields.java
@@ -2,6 +2,8 @@
 
 // MUST BE ORDERED BY THE ORDER OF OF SPEC!!!
 public enum MatchFields {
+    // if present, PacketType must appear as the first OXM in the list (OF 1.5., 7.2.3.11)
+    PACKET_TYPE,
     IN_PORT,
     IN_PHY_PORT,
     METADATA,
@@ -46,6 +48,9 @@
     CONNTRACK_LABEL,
     IPV6_EXTHDR,
     PBB_UCA,
+    TCP_FLAGS,
+    OVS_TCP_FLAGS,
+    ACTSET_OUTPUT,
     TUNNEL_IPV4_SRC,
     TUNNEL_IPV4_DST,
     BSN_IN_PORTS_128,
@@ -73,6 +78,7 @@
     BSN_INNER_ETH_DST,
     BSN_INNER_ETH_SRC,
     BSN_INNER_VLAN_VID,
+    BSN_VFI,
     OCH_SIGTYPE,
     OCH_SIGTYPE_BASIC,
     OCH_SIGID,
@@ -111,4 +117,5 @@
     OFDPA_MPLS_TYPE,
     OFDPA_MPLS_L2_PORT,
     OFDPA_OVID,
+    BSN_IP_FRAGMENTATION
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/Prerequisite.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/Prerequisite.java
index 03d5e79..dec9d21 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/Prerequisite.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/match/Prerequisite.java
@@ -1,7 +1,7 @@
 package org.projectfloodlight.openflow.protocol.match;
 
-import java.util.HashSet;
 import java.util.Set;
+import com.google.common.collect.ImmutableSet;
 
 import org.projectfloodlight.openflow.types.OFValueType;
 
@@ -12,15 +12,14 @@
 
     @SafeVarargs
     public Prerequisite(MatchField<T> field, OFValueType<T>... values) {
-        this.values = new HashSet<OFValueType<T>>();
         this.field = field;
+        /* possible null values, since public constructor */
         if (values == null || values.length == 0) {
             this.any = true;
+            this.values = ImmutableSet.of();
         } else {
             this.any = false;
-            for (OFValueType<T> value : values) {
-                this.values.add(value);
-            }
+            this.values = ImmutableSet.copyOf(values);
         }
     }
 
@@ -42,4 +41,22 @@
         return false;
     }
 
+    /**
+     * Get valid/possible values for this prerequisite match.
+     *
+     * @return unmodifiable set of possible values
+     */
+    public Set<OFValueType<T>> getValues() {
+        return this.values;   
+    }
+
+    /**
+     * Get the MatchField of this prerequisite.
+     *
+     * @return the MatchField that is required
+     */
+    public MatchField<T> getMatchField() {
+        return this.field; /* immutable */
+    }
+
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/Stat.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/Stat.java
new file mode 100644
index 0000000..618592a
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/Stat.java
@@ -0,0 +1,28 @@
+package org.projectfloodlight.openflow.protocol.stat;
+
+import org.projectfloodlight.openflow.protocol.OFObject;
+import org.projectfloodlight.openflow.types.OFValueType;
+
+public interface Stat extends OFObject {
+    public <F extends OFValueType<F>> F get(StatField<F> field) throws UnsupportedOperationException;
+    public boolean supports(StatField<?> field);
+    public Iterable<StatField<?>> getStatFields();
+    public Builder createBuilder();
+
+    interface Builder {
+        public <F extends OFValueType<F>> F get(StatField<F> field) throws UnsupportedOperationException;
+        /**
+         * Sets a specific value for a stat field.
+         *
+         * @param <F> StatField type
+         * @param field Stat field to set.
+         * @param value Value of stat field.
+         * @return the Builder instance used.
+         * @throws UnsupportedOperationException If field is not supported.
+         */
+        public <F extends OFValueType<F>> Builder set(StatField<F> field, F value) throws UnsupportedOperationException;
+
+        public boolean supports(StatField<?> field);
+        public Stat build();
+    }
+}
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/StatField.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/StatField.java
new file mode 100644
index 0000000..b2bb911
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/StatField.java
@@ -0,0 +1,36 @@
+package org.projectfloodlight.openflow.protocol.stat;
+
+import org.projectfloodlight.openflow.types.OFValueType;
+import org.projectfloodlight.openflow.types.U32;
+import org.projectfloodlight.openflow.types.U64;
+
+public class StatField<F extends OFValueType<F>> {
+
+    private final String name;
+    public final StatFields id;
+
+    private StatField(final String name, final StatFields id) {
+        this.name = name;
+        this.id = id;
+    }
+
+    public final static StatField<U64> DURATION =
+            new StatField<U64>("of_duration", StatFields.DURATION);
+
+    public final static StatField<U64> IDLE_TIME =
+            new StatField<U64>("of_idle_time", StatFields.IDLE_TIME);
+
+    public final static StatField<U32> FLOW_COUNT =
+            new StatField<U32>("of_flow_count", StatFields.FLOW_COUNT);
+
+    public final static StatField<U64> PACKET_COUNT =
+            new StatField<U64>("of_packet_count", StatFields.PACKET_COUNT);
+
+    public final static StatField<U64> BYTE_COUNT =
+            new StatField<U64>("of_byte_count", StatFields.BYTE_COUNT);
+
+    public String getName() {
+        return name;
+    }
+
+}
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/StatFields.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/StatFields.java
new file mode 100644
index 0000000..374a92b
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/stat/StatFields.java
@@ -0,0 +1,10 @@
+package org.projectfloodlight.openflow.protocol.stat;
+
+//MUST BE ORDERED BY THE ORDER OF OF SPEC!!!
+public enum StatFields {
+    DURATION,
+    IDLE_TIME,
+    FLOW_COUNT,
+    PACKET_COUNT,
+    BYTE_COUNT,
+}
\ No newline at end of file
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver10/ChannelUtilsVer10.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver10/ChannelUtilsVer10.java
index b4937ba..74f75ba 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver10/ChannelUtilsVer10.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver10/ChannelUtilsVer10.java
@@ -3,25 +3,26 @@
 import java.util.EnumSet;
 import java.util.Set;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFActionType;
 import org.projectfloodlight.openflow.protocol.match.Match;
+import org.projectfloodlight.openflow.protocol.stat.Stat;
 
 import com.google.common.hash.PrimitiveSink;
 
 /**
- * Collection of helper functions for reading and writing into ChannelBuffers
+ * Collection of helper functions for reading and writing into Unpooled
  *
  * @author capveg
  */
 
 public class ChannelUtilsVer10 {
-    public static Match readOFMatch(final ChannelBuffer bb) throws OFParseError {
+    public static Match readOFMatch(final ByteBuf bb) throws OFParseError {
         return OFMatchV1Ver10.READER.readFrom(bb);
     }
 
-    public static Set<OFActionType> readSupportedActions(ChannelBuffer bb) {
+    public static Set<OFActionType> readSupportedActions(ByteBuf bb) {
         int actions = bb.readInt();
         EnumSet<OFActionType> supportedActions = EnumSet.noneOf(OFActionType.class);
         if ((actions & (1 << OFActionTypeSerializerVer10.OUTPUT_VAL)) != 0)
@@ -84,8 +85,12 @@
         sink.putInt(supportedActionsToWire(supportedActions));
     }
 
-    public static void writeSupportedActions(ChannelBuffer bb, Set<OFActionType> supportedActions) {
+    public static void writeSupportedActions(ByteBuf bb, Set<OFActionType> supportedActions) {
         bb.writeInt(supportedActionsToWire(supportedActions));
     }
 
+    public static Stat readOFStat(final ByteBuf bb) throws OFParseError {
+        throw new UnsupportedOperationException("not supported");
+    }
+
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver11/ChannelUtilsVer11.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver11/ChannelUtilsVer11.java
index b090e47..b09da37 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver11/ChannelUtilsVer11.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver11/ChannelUtilsVer11.java
@@ -1,26 +1,31 @@
 package org.projectfloodlight.openflow.protocol.ver11;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMatchBmap;
 import org.projectfloodlight.openflow.protocol.match.Match;
+import org.projectfloodlight.openflow.protocol.stat.Stat;
 
 /**
- * Collection of helper functions for reading and writing into ChannelBuffers
+ * Collection of helper functions for reading and writing into Unpooled
  *
  * @author capveg
  */
 
 public class ChannelUtilsVer11 {
-    public static Match readOFMatch(final ChannelBuffer bb) throws OFParseError {
+    public static Match readOFMatch(final ByteBuf bb) throws OFParseError {
         return OFMatchV2Ver11.READER.readFrom(bb);
     }
 
-    public static OFMatchBmap readOFMatchBmap(ChannelBuffer bb) {
+    public static OFMatchBmap readOFMatchBmap(ByteBuf bb) {
         throw new UnsupportedOperationException("not implemented");
     }
 
-    public static void writeOFMatchBmap(ChannelBuffer bb, OFMatchBmap match) {
+    public static void writeOFMatchBmap(ByteBuf bb, OFMatchBmap match) {
         throw new UnsupportedOperationException("not implemented");
     }
+
+    public static Stat readOFStat(final ByteBuf bb) throws OFParseError {
+        throw new UnsupportedOperationException("not supported");
+    }
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver12/ChannelUtilsVer12.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver12/ChannelUtilsVer12.java
index 756363d..5b28170 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver12/ChannelUtilsVer12.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver12/ChannelUtilsVer12.java
@@ -1,40 +1,45 @@
 package org.projectfloodlight.openflow.protocol.ver12;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMatchBmap;
 import org.projectfloodlight.openflow.protocol.match.Match;
 import org.projectfloodlight.openflow.protocol.ver12.OFMatchV3Ver12;
 import org.projectfloodlight.openflow.protocol.OFBsnVportQInQ;
+import org.projectfloodlight.openflow.protocol.stat.Stat;
 
 /**
- * Collection of helper functions for reading and writing into ChannelBuffers
+ * Collection of helper functions for reading and writing into Unpooled
  *
  * @author capveg
  */
 
 public class ChannelUtilsVer12 {
-    public static Match readOFMatch(final ChannelBuffer bb) throws OFParseError {
+    public static Match readOFMatch(final ByteBuf bb) throws OFParseError {
         return OFMatchV3Ver12.READER.readFrom(bb);
     }
 
     // TODO these need to be figured out / removed
 
-    public static OFBsnVportQInQ readOFBsnVportQInQ(ChannelBuffer bb) {
+    public static OFBsnVportQInQ readOFBsnVportQInQ(ByteBuf bb) {
         throw new UnsupportedOperationException("not implemented");
     }
 
-    public static void writeOFBsnVportQInQ(ChannelBuffer bb,
+    public static void writeOFBsnVportQInQ(ByteBuf bb,
             OFBsnVportQInQ vport) {
         throw new UnsupportedOperationException("not implemented");
 
     }
 
-    public static OFMatchBmap readOFMatchBmap(ChannelBuffer bb) {
+    public static OFMatchBmap readOFMatchBmap(ByteBuf bb) {
         throw new UnsupportedOperationException("not implemented");
     }
 
-    public static void writeOFMatchBmap(ChannelBuffer bb, OFMatchBmap match) {
+    public static void writeOFMatchBmap(ByteBuf bb, OFMatchBmap match) {
         throw new UnsupportedOperationException("not implemented");
     }
+
+    public static Stat readOFStat(final ByteBuf bb) throws OFParseError {
+        throw new UnsupportedOperationException("not supported");
+    }
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver13/ChannelUtilsVer13.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver13/ChannelUtilsVer13.java
index 8216bb0..cd65bcd 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver13/ChannelUtilsVer13.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver13/ChannelUtilsVer13.java
@@ -1,26 +1,31 @@
 package org.projectfloodlight.openflow.protocol.ver13;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMatchBmap;
 import org.projectfloodlight.openflow.protocol.match.Match;
+import org.projectfloodlight.openflow.protocol.stat.Stat;
 
 /**
- * Collection of helper functions for reading and writing into ChannelBuffers
+ * Collection of helper functions for reading and writing into Unpooled
  *
  * @author capveg
  */
 
 public class ChannelUtilsVer13 {
-    public static Match readOFMatch(final ChannelBuffer bb) throws OFParseError {
+    public static Match readOFMatch(final ByteBuf bb) throws OFParseError {
         return OFMatchV3Ver13.READER.readFrom(bb);
     }
 
-    public static OFMatchBmap readOFMatchBmap(ChannelBuffer bb) {
+    public static OFMatchBmap readOFMatchBmap(ByteBuf bb) {
         throw new UnsupportedOperationException("not implemented");
     }
 
-    public static void writeOFMatchBmap(ChannelBuffer bb, OFMatchBmap match) {
+    public static void writeOFMatchBmap(ByteBuf bb, OFMatchBmap match) {
         throw new UnsupportedOperationException("not implemented");
     }
+
+    public static Stat readOFStat(final ByteBuf bb) throws OFParseError {
+        throw new UnsupportedOperationException("not supported");
+    }
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver14/ChannelUtilsVer14.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver14/ChannelUtilsVer14.java
index c893cab..f062711 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver14/ChannelUtilsVer14.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver14/ChannelUtilsVer14.java
@@ -1,26 +1,31 @@
 package org.projectfloodlight.openflow.protocol.ver14;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMatchBmap;
 import org.projectfloodlight.openflow.protocol.match.Match;
+import org.projectfloodlight.openflow.protocol.stat.Stat;
 
 /**
- * Collection of helper functions for reading and writing into ChannelBuffers
+ * Collection of helper functions for reading and writing into ByteBufs
  *
  * @author capveg
  */
 
 public class ChannelUtilsVer14 {
-    public static Match readOFMatch(final ChannelBuffer bb) throws OFParseError {
+    public static Match readOFMatch(final ByteBuf bb) throws OFParseError {
         return OFMatchV3Ver14.READER.readFrom(bb);
     }
 
-    public static OFMatchBmap readOFMatchBmap(ChannelBuffer bb) {
+    public static OFMatchBmap readOFMatchBmap(ByteBuf bb) {
         throw new UnsupportedOperationException("not implemented");
     }
 
-    public static void writeOFMatchBmap(ChannelBuffer bb, OFMatchBmap match) {
+    public static void writeOFMatchBmap(ByteBuf bb, OFMatchBmap match) {
         throw new UnsupportedOperationException("not implemented");
     }
+
+    public static Stat readOFStat(final ByteBuf bb) throws OFParseError {
+        throw new UnsupportedOperationException("not supported");
+    }
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver15/ChannelUtilsVer15.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver15/ChannelUtilsVer15.java
new file mode 100644
index 0000000..9142a19
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/protocol/ver15/ChannelUtilsVer15.java
@@ -0,0 +1,30 @@
+package org.projectfloodlight.openflow.protocol.ver15;
+
+import io.netty.buffer.ByteBuf;
+import org.projectfloodlight.openflow.exceptions.OFParseError;
+import org.projectfloodlight.openflow.protocol.OFMatchBmap;
+import org.projectfloodlight.openflow.protocol.match.Match;
+import org.projectfloodlight.openflow.protocol.stat.Stat;
+/**
+ * Collection of helper functions for reading and writing into ByteBufs
+ *
+ * @author capveg
+ */
+
+public class ChannelUtilsVer15 {
+    public static Match readOFMatch(final ByteBuf bb) throws OFParseError {
+        return OFMatchV3Ver15.READER.readFrom(bb);
+    }
+
+    public static Stat readOFStat(final ByteBuf bb) throws OFParseError {
+        return OFStatV6Ver15.READER.readFrom(bb);
+    }
+
+    public static OFMatchBmap readOFMatchBmap(ByteBuf bb) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    public static void writeOFMatchBmap(ByteBuf bb, OFMatchBmap match) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+}
\ No newline at end of file
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ArpOpcode.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ArpOpcode.java
index dd50d29..2fb2816 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ArpOpcode.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ArpOpcode.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedInts;
@@ -146,11 +146,11 @@
         }
     }
 
-    public void write2Bytes(ChannelBuffer c) {
+    public void write2Bytes(ByteBuf c) {
         c.writeShort(this.opcode);
     }
 
-    public static ArpOpcode read2Bytes(ChannelBuffer c) {
+    public static ArpOpcode read2Bytes(ByteBuf c) {
         return ArpOpcode.of(c.readUnsignedShort());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/BundleId.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/BundleId.java
index cccf67e..7f6b496 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/BundleId.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/BundleId.java
@@ -2,7 +2,7 @@
 
 import javax.annotation.concurrent.Immutable;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedInts;
@@ -72,11 +72,11 @@
         return true;
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(rawValue);
     }
 
-    public static BundleId read4Bytes(ChannelBuffer c) {
+    public static BundleId read4Bytes(ByteBuf c) {
         return BundleId.of(c.readInt());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/CircuitSignalID.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/CircuitSignalID.java
index 7a304f6..91eebe0 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/CircuitSignalID.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/CircuitSignalID.java
@@ -1,7 +1,7 @@
 package org.projectfloodlight.openflow.types;
 
 import com.google.common.collect.ComparisonChain;
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -53,14 +53,14 @@
         return spectralWidth;
     }
 
-    public void write6Bytes(ChannelBuffer c) {
+    public void write6Bytes(ByteBuf c) {
         c.writeByte(gridType);
         c.writeByte(channelSpacing);
         c.writeShort(channelNumber);
         c.writeShort(spectralWidth);
     }
 
-    public static CircuitSignalID read6Bytes(ChannelBuffer c) throws OFParseError {
+    public static CircuitSignalID read6Bytes(ByteBuf c) throws OFParseError {
         return new CircuitSignalID((byte)c.readUnsignedByte(),
                                    (byte)c.readUnsignedByte(),
                                    (short)c.readUnsignedShort(),
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ClassId.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ClassId.java
index 98c1253..c5f18cd 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ClassId.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ClassId.java
@@ -2,7 +2,7 @@
 
 import javax.annotation.concurrent.Immutable;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedInts;
@@ -72,11 +72,11 @@
         return true;
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(rawValue);
     }
 
-    public static ClassId read4Bytes(ChannelBuffer c) {
+    public static ClassId read4Bytes(ByteBuf c) {
         return ClassId.of(c.readInt());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/EthType.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/EthType.java
index 1d9c8d6..a7c1464 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/EthType.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/EthType.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedInts;
@@ -59,6 +59,7 @@
     static final int VAL_CONF_TEST         = 0x9000; // Ethernet Configuration Testing Protocol[6]
     static final int VAL_Q_IN_Q            = 0x9100; // Q-in-Q
     static final int VAL_LLT               = 0xCAFE; // Veritas Low Latency Transport (LLT)[7] for Veritas Cluster Server
+    static final int VAL_PBB               = 0x88E7; // Provider Backbone Bridges (PBB)
 
     public static final EthType IPv4               = new EthType(VAL_IPv4);
     public static final EthType ARP                = new EthType(VAL_ARP);
@@ -103,6 +104,7 @@
     public static final EthType CONF_TEST          = new EthType(VAL_CONF_TEST );
     public static final EthType Q_IN_Q             = new EthType(VAL_Q_IN_Q );
     public static final EthType LLT                = new EthType(VAL_LLT );
+    public static final EthType PBB                = new EthType(VAL_PBB );
 
 
     private static final int NONE_VAL = 0x0;
@@ -210,6 +212,8 @@
                 return Q_IN_Q;
             case VAL_LLT:
                 return LLT;
+            case VAL_PBB:
+                return PBB;
             default:
                 // TODO: What's here?
                 return new EthType(type);
@@ -221,11 +225,11 @@
         return "0x" + Integer.toHexString(rawValue);
     }
 
-    public void write2Bytes(ChannelBuffer c) {
+    public void write2Bytes(ByteBuf c) {
         c.writeShort(this.rawValue);
     }
 
-    public static EthType read2Bytes(ChannelBuffer c) {
+    public static EthType read2Bytes(ByteBuf c) {
         return EthType.of(c.readUnsignedShort());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/GenTableId.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/GenTableId.java
index cfa7cdf..2127bef 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/GenTableId.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/GenTableId.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -51,11 +51,11 @@
         return LENGTH;
     }
 
-    public void write2Bytes(ChannelBuffer c) {
+    public void write2Bytes(ByteBuf c) {
         c.writeShort(this.id);
     }
 
-    public static GenTableId read2Bytes(ChannelBuffer c) throws OFParseError {
+    public static GenTableId read2Bytes(ByteBuf c) throws OFParseError {
         return GenTableId.of(c.readUnsignedShort());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/HashValue.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/HashValue.java
index ee736d7..5e8bb72 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/HashValue.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/HashValue.java
@@ -7,7 +7,7 @@
  *
  * @author Andreas Wundsam {@literal <}andreas.wundsam@bigswitch.com{@literal >}
  *
- * @param <H> - this type, for return type safety.
+ * @param H - this type, for return type safety.
  */
 @Immutable
 public interface HashValue<H extends HashValue<H>> {
@@ -20,7 +20,7 @@
     /** perform an arithmetic addition of this value and other. Wraps around on
      * overflow of the defined word size.
      *
-     * @param other
+     * @param other the other value to add to this
      * @return this + other
      */
     H add(H other);
@@ -29,7 +29,7 @@
      * arithmetically substract the given 'other' value from this value.
      * around on overflow.
      *
-     * @param other
+     * @param other the other value to subtract from this
      * @return this - other
      */
     H subtract(H other);
@@ -37,32 +37,53 @@
     /** @return the bitwise inverse of this value */
     H inverse();
 
-    /** or this value with another value value of the same type */
+    /** 
+     * or this value with another value value of the same type 
+     * 
+     * @param other the other value to bitwise or with this
+     * @return this | other
+     */
     H or(H other);
 
-    /** and this value with another value value of the same type */
+    /** 
+     * and this value with another value value of the same type 
+     * 
+     * @param other the other value to bitwise and with this
+     * @return this {@literal &} other
+     */
     H and(H other);
 
-    /** xor this value with another value value of the same type */
+    /** 
+     * xor this value with another value value of the same type 
+     *
+     * @param other the other value to bitwise xor with this
+     * @return this XOR other
+     */
     H xor(H other);
 
-    /** create and return a builder */
+    /** 
+     * create and return a builder 
+     *
+     * @return builder
+     */
     Builder<H> builder();
 
-    /** a mutator for HashValues. Allows perfomring a series of
-     *  operations on a hashv value without the associated cost of object
-     *  reallocation.
+    /** 
+     * a mutator for HashValues. Allows perfomring a series of
+     * operations on a hashv value without the associated cost of object
+     * reallocation.
      *
      * @author Andreas Wundsam {@literal <}andreas.wundsam@bigswitch.com{@literal >}
      *
      * @param <H> - the hashvalue
      */
     public interface Builder<H> {
-        /** perform an arithmetic addition of this value and other. Wraps around on
+        /** 
+         * perform an arithmetic addition of this value and other. Wraps around on
          * overflow of the defined word size.
          *
-         * @param other
-         * @return this mutator
+         * @param other the other value to add to this
+         * @return this mutator containing this + other
          */
         Builder<H> add(H other);
 
@@ -70,33 +91,47 @@
          * arithmetically substract the given 'other' value from the value stored in this mutator.
          * around on overflow.
          *
-         * @param other
-         * @return this mutator
+         * @param other the other value to subtract from this
+         * @return this mutator containing this - other
          */
         Builder<H> subtract(H other);
 
-        /** bitwise invert the value stored in this mutator
+        /** 
+         * bitwise invert the value stored in this mutator
          *
-         * @return this mutator
+         * @return this mutator containing ~this
          */
         Builder<H> invert();
 
-        /** or the value stored in this mutator with another value value of the same type
-        * @return this mutator
-        */
+        /** 
+         * or the value stored in this mutator with another value value of the same type
+         *
+         * @param other the other value to bitwise or with this
+         * @return this mutator containing this | other
+         */
         Builder<H> or(H other);
 
-        /** and the value stored in this mutator with another value value of the same type
-        * @return this mutator
-        */
+        /** 
+         * and the value stored in this mutator with another value value of the same type
+         *
+         * @param other the other value to bitwise and with this
+         * @return this mutator containing this {@literal &} other
+         */
         Builder<H> and(H other);
 
-        /** xor the value stored in this mutator with another value value of the same type
-        * @return this mutator
-        */
+        /** 
+         * xor the value stored in this mutator with another value value of the same type
+         *
+         * @param other the other value to bitwise exclusive or with this
+         * @return this mutator containing this XOR other
+         */
         Builder<H> xor(H other);
 
-        /** @return the hash value */
+        /** 
+         * construct an immutable value from the value defined in the builder
+         *
+         * @return the hash value 
+         */
         public H build();
     }
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ICMPv4Code.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ICMPv4Code.java
index ced5737..597095d 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ICMPv4Code.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ICMPv4Code.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.Shorts;
@@ -45,11 +45,11 @@
         return code;
     }
 
-    public void writeByte(ChannelBuffer c) {
+    public void writeByte(ByteBuf c) {
         c.writeByte(this.code);
     }
 
-    public static ICMPv4Code readByte(ChannelBuffer c) {
+    public static ICMPv4Code readByte(ByteBuf c) {
         return ICMPv4Code.of(c.readUnsignedByte());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ICMPv4Type.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ICMPv4Type.java
index 634bc03..3eb2987 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ICMPv4Type.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/ICMPv4Type.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.Shorts;
@@ -155,11 +155,11 @@
         return type;
     }
 
-    public void writeByte(ChannelBuffer c) {
+    public void writeByte(ByteBuf c) {
         c.writeByte(this.type);
     }
 
-    public static ICMPv4Type readByte(ChannelBuffer c) {
+    public static ICMPv4Type readByte(ByteBuf c) {
         return ICMPv4Type.of(c.readUnsignedByte());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPAddress.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPAddress.java
index ad21e06..cc91ebf 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPAddress.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPAddress.java
@@ -34,13 +34,49 @@
     public abstract int asCidrMaskLength();
 
     /**
+     * Returns {@code true} if the IPAddress is unspecified.
+     *
+     * <p>The <em>unspecified</em> addresses, also known as the
+     * <em>wildcard</em> addresses, refer to:
+     * <ul>
+     * <li>the {@link IPv4Address} of {@code 0.0.0.0}
+     * <li>the {@link IPv6Address} of {@code ::}
+     * </ul>
+     * @return {@code true} if the IPAddress is unspecified, false otherwise
+     */
+    public abstract boolean isUnspecified();
+
+    /**
+     * Returns {@code true} if the IPAddress is a loopback address.
+     *
+     * <p><em>Loopback</em> addresses refer to:
+     * <ul>
+     * <li>any {@link IPv4Address} within {@code 127.0.0.0/8}
+     * <li>the {@link IPv6Address} of {@code ::1}
+     * </ul>
+     * @return {@code true} if the IPAddress is a loopback address, false otherwise
+     */
+    public abstract boolean isLoopback();
+
+    /**
+     * Returns {@code true} if the IPAddress is a link local address.
+     *
+     * <p><em>Link local</em> addresses refer to:
+     * <ul>
+     * <li>any {@link IPv4Address} within {@code 169.254.0.0/16}
+     * <li>any {@link IPv6Address} within {@code fe80::/10}
+     * </ul>
+     * @return {@code true} if the IPAddress is a link local address, false otherwise
+     */
+    public abstract boolean isLinkLocal();
+
+    /**
      * Checks if the IPAddress is the global broadcast address
      * 255.255.255.255 in case of IPv4
      * @return boolean true or false
      */
     public abstract boolean isBroadcast();
 
-
     /**
      * Checks if the IPAddress is the multicast address
      * @return boolean true or false
@@ -111,6 +147,20 @@
      */
     public abstract byte[] getBytes();
 
+    /**
+     * Returns an {@link InetAddress} object representing this IP address.
+     *
+     * <p>The resulting {@link InetAddress} object:
+     * <ul>
+     * <li>will not carry a hostname
+     * <li>will not carry a non-zero scope ID or scoped interface,
+     *     in the case of {@link Inet6Address}
+     * </ul>
+     * @return an {@link InetAddress} object representing this IP address
+     */
+    @Nonnull
+    public abstract InetAddress toInetAddress();
+
     @Override
     public abstract String toString();
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv4Address.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv4Address.java
index 53e8071..37dd919 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv4Address.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv4Address.java
@@ -1,21 +1,24 @@
 package org.projectfloodlight.openflow.types;
 
+import io.netty.buffer.ByteBuf;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
 import java.net.Inet4Address;
 import java.net.InetAddress;
+import java.net.UnknownHostException;
 import java.util.Arrays;
 
 import javax.annotation.Nonnull;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import org.projectfloodlight.openflow.exceptions.OFParseError;
+import org.projectfloodlight.openflow.protocol.OFMessageReader;
+import org.projectfloodlight.openflow.protocol.Writeable;
 
 import com.google.common.base.Preconditions;
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedInts;
 
-import org.projectfloodlight.openflow.protocol.Writeable;
-import org.projectfloodlight.openflow.protocol.OFMessageReader;
-import org.projectfloodlight.openflow.exceptions.OFParseError;
-
 /**
  * Wrapper around an IPv4Address address
  *
@@ -44,7 +47,7 @@
 
     private static class Reader implements OFMessageReader<IPv4Address> {
         @Override
-        public IPv4Address readFrom(ChannelBuffer bb) throws OFParseError {
+        public IPv4Address readFrom(ByteBuf bb) throws OFParseError {
             return new IPv4Address(bb.readInt());
         }
     }
@@ -86,18 +89,34 @@
     }
 
     @Override
+    public boolean isUnspecified() {
+        return this.equals(NONE);
+    }
+
+    @Override
+    public boolean isLoopback() {
+        return ((rawValue >>> 24) & 0xFF) == 127;
+    }
+
+    @Override
+    public boolean isLinkLocal() {
+        return ((rawValue >>> 24) & 0xFF) == 169
+                && ((rawValue >>> 16) & 0xFF) == 254;
+    }
+
+    @Override
     public boolean isBroadcast() {
         return this.equals(NO_MASK);
     }
 
     /**
-     * IPv4 multicast addresses are defined by the leading address bits of 1110 
+     * IPv4 multicast addresses are defined by the leading address bits of 1110
      */
     @Override
     public boolean isMulticast() {
         return ((rawValue >>> 24) & 0xF0) == 0xE0;
     }
-    
+
     @Override
     public IPv4Address and(IPv4Address other) {
         Preconditions.checkNotNull(other, "other must not be null");
@@ -153,6 +172,48 @@
 
     /**
      * Returns an {@code IPv4Address} object that represents the given
+     * IP address. The arguments are in network byte order: the highest
+     * order byte of the address is in {@code octet1}.
+     *
+     * <p>For example, {@code IPv4Address.of(192, 0, 2, 101)} yields
+     * the IPv4 address of {@code "192.0.2.101"}.
+     *
+     * <p>Use caution when providing byte-typed values as arguments.
+     * "Byte-typed values" here refer to values that are of either the
+     * primitive {@code byte} type or the corresponding object wrapper
+     * class {@link Byte}. Byte-typed values greater than 127 are
+     * essentially negative values and will be casted to negative
+     * {@code int} values, thus failing the numeric range checks
+     * enforced by this method. Consider using {@link #of(byte[])}
+     * instead when handling byte-typed values.
+     *
+     * @throws IllegalArgumentException if any of the octets were
+     *         negative or greater than 255
+     * @param octet1 the highest order byte in network byte order
+     * @param octet2 the 2nd-highest order byte in network byte order
+     * @param octet3 the 2nd-lowest order byte in network byte order
+     * @param octet4 the lowest order byte in network byte order
+     * @return an {@code IPv4Address} object that represents the given
+     * IP address
+     */
+    @Nonnull
+    public static IPv4Address of(
+            int octet1, int octet2, int octet3, int octet4) {
+        checkArgument((octet1 & 0xFF) == octet1
+                && (octet2 & 0xFF) == octet2
+                && (octet3 & 0xFF) == octet3
+                && (octet4 & 0xFF) == octet4,
+                "Invalid IPv4 address %s.%s.%s.%s",
+                octet1, octet2, octet3, octet4);
+        int raw = (octet1 & 0xFF) << 24
+                | (octet2 & 0xFF) << 16
+                | (octet3 & 0xFF) << 8
+                | (octet4 & 0xFF) << 0;
+        return IPv4Address.of(raw);
+    }
+
+    /**
+     * Returns an {@code IPv4Address} object that represents the given
      * IP address.
      *
      * @param raw  the raw IP address represented as a 32-bit integer
@@ -309,6 +370,17 @@
         return LENGTH;
     }
 
+    @Nonnull
+    @Override
+    public Inet4Address toInetAddress() {
+        try {
+            return (Inet4Address) InetAddress.getByAddress(getBytes());
+        } catch (UnknownHostException e) {
+            throw new IllegalArgumentException(
+                    "Error getting InetAddress for the IPAddress " + this, e);
+        }
+    }
+
     @Override
     public String toString() {
         StringBuilder res = new StringBuilder();
@@ -319,11 +391,11 @@
         return res.toString();
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(rawValue);
     }
 
-    public static IPv4Address read4Bytes(ChannelBuffer c) {
+    public static IPv4Address read4Bytes(ByteBuf c) {
         return IPv4Address.of(c.readInt());
     }
 
@@ -365,7 +437,7 @@
     }
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         bb.writeInt(rawValue);
     }
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6Address.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6Address.java
index fee04ac..497a40c 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6Address.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6Address.java
@@ -1,22 +1,26 @@
 package org.projectfloodlight.openflow.types;
 
+import io.netty.buffer.ByteBuf;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import java.net.Inet6Address;
 import java.net.InetAddress;
+import java.net.UnknownHostException;
 import java.util.Arrays;
 import java.util.regex.Pattern;
 
 import javax.annotation.Nonnull;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import org.projectfloodlight.openflow.exceptions.OFParseError;
+import org.projectfloodlight.openflow.protocol.OFMessageReader;
+import org.projectfloodlight.openflow.protocol.Writeable;
 
 import com.google.common.base.Preconditions;
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedLongs;
 
-import org.projectfloodlight.openflow.protocol.Writeable;
-import org.projectfloodlight.openflow.protocol.OFMessageReader;
-import org.projectfloodlight.openflow.exceptions.OFParseError;
-
 /**
  * IPv6 address object. Instance controlled, immutable. Internal representation:
  * two 64 bit longs (not that you'd have to know).
@@ -24,7 +28,7 @@
  * @author Andreas Wundsam {@literal <}andreas.wundsam@teleteach.de{@literal >}
  */
 public class IPv6Address extends IPAddress<IPv6Address> implements Writeable {
-    static final int LENGTH = 16;
+    public static final int LENGTH = 16;
     private final long raw1;
     private final long raw2;
 
@@ -50,7 +54,7 @@
 
     private static class Reader implements OFMessageReader<IPv6Address> {
         @Override
-        public IPv6Address readFrom(ChannelBuffer bb) throws OFParseError {
+        public IPv6Address readFrom(ByteBuf bb) throws OFParseError {
             return new IPv6Address(bb.readLong(), bb.readLong());
         }
     }
@@ -111,18 +115,74 @@
     }
 
     @Override
+    public boolean isUnspecified() {
+        return this.equals(NONE);
+    }
+
+    @Override
+    public boolean isLoopback() {
+        return raw1 == 0 && raw2 == 1;
+    }
+
+    @Override
+    public boolean isLinkLocal() {
+        return (raw1 & 0xFFC0_0000_0000_0000L) == 0xFE80_0000_0000_0000L;
+    }
+
+    @Override
     public boolean isBroadcast() {
         return this.equals(NO_MASK);
     }
 
     /**
-     * IPv6 multicast addresses are defined by the prefix ff00::/8 
+     * IPv6 multicast addresses are defined by the prefix ff00::/8
      */
     @Override
     public boolean isMulticast() {
         return (raw1 >>> 56) == 0xFFL;
     }
-    
+
+    /**
+     * Returns the Modified EUI-64 format interface identifier that
+     * corresponds to the specified MAC address.
+     *
+     * <p>Refer to the followings for the conversion details:
+     * <ul>
+     * <li>RFC 7042 - Section 2.2.1
+     * <li>RFC 5342 - Section 2.2.1 (Obsoleted by RFC 7042)
+     * <li>RFC 4291 - Appendix A
+     * </ul>
+     */
+    private static long toModifiedEui64(@Nonnull MacAddress macAddress) {
+        checkNotNull(macAddress, "macAddress must not be null");
+        return   ((0xFFFF_FF00_0000_0000L & (macAddress.getLong() << 16))
+                ^ (0x0200_0000_0000_0000L))
+                | (0x0000_00FF_FE00_0000L)
+                | (0x0000_0000_00FF_FFFFL & macAddress.getLong());
+    }
+
+    /**
+     * Returns {@code true} if the second (lower-order) 64-bit block of
+     * this address is equal to the Modified EUI-64 format interface
+     * identifier that corresponds to the specified MAC address.
+     *
+     * <p>Refer to the followings for the details of conversions between
+     * MAC addresses and Modified EUI-64 format interface identifiers:
+     * <ul>
+     * <li>RFC 7042 - Section 2.2.1
+     * <li>RFC 5342 - Section 2.2.1 (Obsoleted by RFC 7042)
+     * <li>RFC 4291 - Appendix A
+     * </ul>
+     *
+     * <p>This method assumes the second (lower-order) 64-bit block to be
+     * a 64-bit interface identifier, which may not always be true.
+     * @param macAddress the MAC address to check
+     * @return boolean true or false
+     */
+    public boolean isModifiedEui64Derived(@Nonnull MacAddress macAddress) {
+        return raw2 == toModifiedEui64(macAddress);
+    }
+
     @Override
     public IPv6Address and(IPv6Address other) {
         Preconditions.checkNotNull(other, "other must not be null");
@@ -329,6 +389,54 @@
     }
 
     /**
+     * Returns an {@code IPv6Address} object that represents the given
+     * MAC address in the specified network.
+     *
+     * <p>The first (higher-order) 64-bit block of the returned address
+     * will be the network prefix derived from the specified network.
+     * The specified network must satisfy the followings:
+     * <ul>
+     * <li>{@link #isCidrMask()} {@code == true}
+     * <li>{@literal 0 <= } {@link #asCidrMaskLength()} {@literal <= 64}
+     * </ul>
+     *
+     * <p>The second (lower-order) 64-bit block of the returned address
+     * will be equal to the Modified EUI-64 format interface identifier
+     * that corresponds to the specified MAC address.
+     *
+     * <p>Refer to the followings for the details of conversions between
+     * MAC addresses and Modified EUI-64 format interface identifiers:
+     * <ul>
+     * <li>RFC 7042 - Section 2.2.1
+     * <li>RFC 5342 - Section 2.2.1 (Obsoleted by RFC 7042)
+     * <li>RFC 4291 - Appendix A
+     * </ul>
+     *
+     * @throws IllegalArgumentException if the specified network does not
+     *         meet the aforementioned requirements
+     * @param network the IPv6 network
+     * @param macAddress the MAC address
+     * @return an {@code IPv6Address} object that represents the given
+     * MAC address in the specified network
+     */
+    @Nonnull
+    public static IPv6Address of(
+            @Nonnull IPv6AddressWithMask network,
+            @Nonnull MacAddress macAddress) {
+
+        checkNotNull(network, "network must not be null");
+        checkArgument(network.getMask().isCidrMask()
+                && network.getMask().asCidrMaskLength() <= 64,
+                "network must consist of a mask of 64 or less leading 1 bits"
+                + " and no other 1 bits: %s", network);
+
+        long raw1 = network.getValue().raw1;
+        long raw2 = toModifiedEui64(macAddress);
+
+        return IPv6Address.of(raw1, raw2);
+    }
+
+    /**
      * Returns an {@code IPv6Address} object that represents the
      * CIDR subnet mask of the given prefix length.
      *
@@ -394,6 +502,7 @@
 
     private volatile byte[] bytesCache = null;
 
+    @Override
     public byte[] getBytes() {
         if (bytesCache == null) {
             synchronized (this) {
@@ -427,6 +536,17 @@
         return LENGTH;
     }
 
+    @Nonnull
+    @Override
+    public Inet6Address toInetAddress() {
+        try {
+            return (Inet6Address) InetAddress.getByAddress(getBytes());
+        } catch (UnknownHostException e) {
+            throw new IllegalArgumentException(
+                    "Error getting InetAddress for the IPAddress " + this, e);
+        }
+    }
+
     @Override
     public String toString() {
         return toString(true, false);
@@ -441,7 +561,11 @@
             throw new IllegalArgumentException("16 bit word index must be in [0,7]");
     }
 
-    /** get the index of the first word where to apply IPv6 zero compression */
+    /** 
+     * get the index of the first word where to apply IPv6 zero compression 
+     *
+     * @return the index
+     */
     public int getZeroCompressStart() {
         int start = Integer.MAX_VALUE;
         int maxLength = -1;
@@ -454,7 +578,7 @@
                 if (getUnsignedShortWord(i) != 0) {
                     // end of this candidate word
                     int candidateLength = i - candidateStart;
-                    if (candidateLength >= maxLength) {
+                    if ((candidateLength > 1) && (candidateLength > maxLength)) {
                         start = candidateStart;
                         maxLength = candidateLength;
                     }
@@ -470,7 +594,7 @@
 
         if (candidateStart >= 0) {
             int candidateLength = 8 - candidateStart;
-            if (candidateLength >= maxLength) {
+            if ((candidateLength > 1) && (candidateLength > maxLength)) {
                 start = candidateStart;
                 maxLength = candidateLength;
             }
@@ -539,12 +663,12 @@
         return true;
     }
 
-    public void write16Bytes(ChannelBuffer c) {
+    public void write16Bytes(ByteBuf c) {
         c.writeLong(this.raw1);
         c.writeLong(this.raw2);
     }
 
-    public static IPv6Address read16Bytes(ChannelBuffer c) throws OFParseError {
+    public static IPv6Address read16Bytes(ByteBuf c) throws OFParseError {
         return IPv6Address.of(c.readLong(), c.readLong());
     }
 
@@ -569,7 +693,7 @@
     }
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         bb.writeLong(raw1);
         bb.writeLong(raw2);
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6AddressWithMask.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6AddressWithMask.java
index ee34923..a50da1a 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6AddressWithMask.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6AddressWithMask.java
@@ -5,6 +5,32 @@
 public class IPv6AddressWithMask extends IPAddressWithMask<IPv6Address> {
     public final static IPv6AddressWithMask NONE = of(IPv6Address.NONE, IPv6Address.NONE);
 
+    /**
+     * Represents the link-local network configuration used in practice,
+     * i.e. {@code fe80::/64}.
+     *
+     * <p>See Section 2.5.6 of RFC 4291.
+     *
+     * @see #LINK_LOCAL_RESERVED
+     */
+    public final static IPv6AddressWithMask LINK_LOCAL_NETWORK
+            = IPv6Address
+                    .of(0xFE80_0000_0000_0000L, 0x0000_0000_0000_0000L)
+                    .withMaskOfLength(64);
+
+    /**
+     * Contains all addresses reserved for link-local usages,
+     * i.e. {@code fe80::/10}.
+     *
+     * <p>See Section 2.4 of RFC 4291.
+     *
+     * @see #LINK_LOCAL_NETWORK
+     */
+    public final static IPv6AddressWithMask LINK_LOCAL_RESERVED
+            = IPv6Address
+                    .of(0xFE80_0000_0000_0000L, 0x0000_0000_0000_0000L)
+                    .withMaskOfLength(10);
+
     private IPv6AddressWithMask(IPv6Address value, IPv6Address mask) {
         super(value, mask);
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6FlowLabel.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6FlowLabel.java
index cfefd39..7c84684 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6FlowLabel.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IPv6FlowLabel.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -56,11 +56,11 @@
         return "0x" + Integer.toHexString(label);
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(this.label);
     }
 
-    public static IPv6FlowLabel read4Bytes(ChannelBuffer c) throws OFParseError {
+    public static IPv6FlowLabel read4Bytes(ByteBuf c) throws OFParseError {
         return IPv6FlowLabel.of((int)(c.readUnsignedInt() & 0xFFFFFFFF));
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpDscp.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpDscp.java
index f19e051..a738ae3 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpDscp.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpDscp.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -230,11 +230,11 @@
         return "0x" + Integer.toHexString(dscp);
     }
 
-    public void writeByte(ChannelBuffer c) {
+    public void writeByte(ByteBuf c) {
         c.writeByte(this.dscp);
     }
 
-    public static IpDscp readByte(ChannelBuffer c) throws OFParseError {
+    public static IpDscp readByte(ByteBuf c) throws OFParseError {
         return IpDscp.of((byte)(c.readUnsignedByte()));
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpEcn.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpEcn.java
index 654df01..eb6ae66 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpEcn.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpEcn.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -49,11 +49,11 @@
         return (ecn < 3 ? "0" : "") + Integer.toBinaryString(ecn);
     }
 
-    public void writeByte(ChannelBuffer c) {
+    public void writeByte(ByteBuf c) {
         c.writeByte(this.ecn);
     }
 
-    public static IpEcn readByte(ChannelBuffer c) throws OFParseError {
+    public static IpEcn readByte(ByteBuf c) throws OFParseError {
         return IpEcn.of((byte)(c.readUnsignedByte()));
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpProtocol.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpProtocol.java
index 8443a31..14e01a7 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpProtocol.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/IpProtocol.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.Shorts;
@@ -615,11 +615,11 @@
         return "0x" + Integer.toHexString(proto);
     }
 
-    public void writeByte(ChannelBuffer c) {
+    public void writeByte(ByteBuf c) {
         c.writeByte(this.proto);
     }
 
-    public static IpProtocol readByte(ChannelBuffer c) {
+    public static IpProtocol readByte(ByteBuf c) {
         return IpProtocol.of(c.readUnsignedByte());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/LagId.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/LagId.java
index 51364e1..04e59d4 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/LagId.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/LagId.java
@@ -2,7 +2,7 @@
 
 import javax.annotation.concurrent.Immutable;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedInts;
@@ -67,11 +67,11 @@
         return true;
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(rawValue);
     }
 
-    public static LagId read4Bytes(ChannelBuffer c) {
+    public static LagId read4Bytes(ByteBuf c) {
         return LagId.of(c.readInt());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/MacAddress.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/MacAddress.java
index b73db43..7a484f4 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/MacAddress.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/MacAddress.java
@@ -4,7 +4,6 @@
 
 import javax.annotation.Nonnull;
 
-import org.jboss.netty.buffer.ChannelBuffer;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.util.HexString;
 
@@ -12,6 +11,8 @@
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.Longs;
 
+import io.netty.buffer.ByteBuf;
+
 /**
  * Wrapper around a 6 byte mac address.
  *
@@ -19,6 +20,7 @@
  */
 
 public class MacAddress implements OFValueType<MacAddress> {
+
     static final int MacAddrLen = 6;
     private final long rawValue;
 
@@ -33,11 +35,16 @@
 
     private static final long LLDP_MAC_ADDRESS_MASK = 0xfffffffffff0L;
     private static final long LLDP_MAC_ADDRESS_VALUE = 0x0180c2000000L;
+    private final static MacAddress IPV4_MULTICAST_BASE_ADDRESS =
+           MacAddress.of("01:00:5E:00:00:00");
+    private final static MacAddress IPV6_MULTICAST_BASE_ADDRESS =
+           MacAddress.of("33:33:00:00:00:00");
 
     private static final String FORMAT_ERROR = "Mac address is not well-formed. " +
-            "It must consist of 6 hex digit pairs separated by colons: ";
+            "It must consist of 6 hex digit pairs separated by colons or hyphens: ";
     private static final int MAC_STRING_LENGTH = 6 * 2 + 5;
 
+
     private MacAddress(final long rawValue) {
         this.rawValue = rawValue;
     }
@@ -62,27 +69,27 @@
         return new MacAddress(raw);
     }
 
-    /** Parse a mac adress from the canonical string representation as
-     *  6 hex bytes separated by colons (01:02:03:04:05:06).
+    /** Parse a mac adress from a string representation as
+     *  6 hex bytes separated by colons or hyphens (01:02:03:04:05:06,
+     *  01-02-03-04-05-06).
      *
-     * @param macString - a mac address in canonical string representation
+     * @param macString - a mac address in string representation
      * @return the parsed MacAddress
      * @throws IllegalArgumentException if macString is not a valid mac adddress
      */
     @Nonnull
     public static MacAddress of(@Nonnull final String macString) throws IllegalArgumentException {
-        if (macString == null) {
-            throw new NullPointerException("macString must not be null");
-        }
+        Preconditions.checkNotNull(macString, "macStringmust not be null");
+        Preconditions.checkArgument(macString.length() == MAC_STRING_LENGTH,
+                FORMAT_ERROR + macString);
+        final char separator = macString.charAt(2);
+        Preconditions.checkArgument(separator == ':' || separator == '-',
+                FORMAT_ERROR + macString + " (invalid separator)");
 
         int index = 0;
         int shift = 40;
         long raw = 0;
 
-        if (macString.length() != MAC_STRING_LENGTH) {
-            throw new IllegalArgumentException(FORMAT_ERROR + macString);
-        }
-
         while (shift >= 0) {
             int digit1 = Character.digit(macString.charAt(index++), 16);
             int digit2 = Character.digit(macString.charAt(index++), 16);
@@ -90,10 +97,16 @@
                 throw new IllegalArgumentException(FORMAT_ERROR + macString);
             raw |= ((long) (digit1 << 4 | digit2)) << shift;
 
-            if (shift == 0)
+            if (shift == 0) {
                 break;
-            if (macString.charAt(index++) != ':')
-                throw new IllegalArgumentException(FORMAT_ERROR + macString);
+            }
+
+            // Iterate over separators
+            if (macString.charAt(index++) != separator) {
+                throw new IllegalArgumentException(FORMAT_ERROR + macString +
+                                                   " (inconsistent separators");
+            }
+
             shift -= 8;
         }
         return MacAddress.of(raw);
@@ -200,12 +213,12 @@
         return rawValue;
     }
 
-    public void write6Bytes(ChannelBuffer c) {
+    public void write6Bytes(ByteBuf c) {
         c.writeInt((int) (this.rawValue >> 16));
         c.writeShort((int) this.rawValue & 0xFFFF);
     }
 
-    public static MacAddress read6Bytes(ChannelBuffer c) throws OFParseError {
+    public static MacAddress read6Bytes(ByteBuf c) throws OFParseError {
         long raw = c.readUnsignedInt() << 16 | c.readUnsignedShort();
         return MacAddress.of(raw);
     }
@@ -222,10 +235,74 @@
 
     @Override
     public void putTo(PrimitiveSink sink) {
-        sink.putInt((int) (this.rawValue >> 16));
-        sink.putShort((short) (this.rawValue & 0xFFFF));
+        sink.putLong(rawValue);
     }
 
+    /*
+     * Parse an IPv4 Multicast address and return the macAddress
+     * corresponding to the multicast IPv4 address.
+     *
+     * For multicast forwarding, the mac addresses in the range
+     * 01-00-5E-00-00-00 to 01-00-5E-7F-FF-FF have been reserved.
+     * The most significant 25 bits of the above 48-bit mac address
+     * are fixed while the lower 23 bits are variable.
+     * These lower 23 bits are derived from the lower 23 bits
+     * of the multicast IP address.
+     *
+     * AND ipv4 address with 0x07FFFFF to extract the last 23 bits
+     * OR with 01:00:5E:00:00:00 MAC (first 25 bits)
+     *
+     * @param ipv4 - ipv4 multicast address
+     * @return the MacAddress corresponding to the multicast address
+     * @throws IllegalArgumentException if ipv4 is not a valid multicast address
+     */
+    @Nonnull
+    public static MacAddress forIPv4MulticastAddress(IPv4Address ipv4)
+            throws IllegalArgumentException {
 
+        if (!ipv4.isMulticast())
+            throw new IllegalArgumentException(
+                    "Not a Multicast IPAddress\"" + ipv4 + "\"");
 
+        long ipLong = ipv4.getInt();
+        int ipMask = 0x007FFFFF;
+        ipLong = ipLong & ipMask;
+
+        long macLong = IPV4_MULTICAST_BASE_ADDRESS.getLong(); // 01:00:5E:00:00:00
+        macLong = macLong | ipLong;
+        MacAddress returnMac = MacAddress.of(macLong);
+
+        return returnMac;
+    }
+
+    /**
+     * Generate a MAC address corresponding to multicast IPv6  address.
+     *
+     * Take the last 4 bytes of IPv6 address and copy them to the base IPv6
+     * multicast mac address - 33:33:00:00:00:00.
+     *
+     * @param ipv6 - IPv6 address corresponding to which multicast MAC addr
+     * need to be generated.
+     * @return - the generated multicast mac address.
+     * @throws IllegalArgumentException if ipv6 address is not a valid IPv6
+     * multicast address.
+     */
+    @Nonnull
+    public static MacAddress forIPv6MulticastAddr(IPv6Address ipv6)
+            throws IllegalArgumentException {
+        if (!ipv6.isMulticast()) {
+            throw new IllegalArgumentException(
+                    "Not a Multicast IPv6Address\"" + ipv6 + "\"");
+        }
+        long ipLong = ((ipv6.getUnsignedShortWord(6) << 16) |
+                                         ipv6.getUnsignedShortWord(7));
+        long ipMask = 0xFFFFFFFFl;
+        ipLong = ipLong & ipMask;
+
+        long macLong = IPV6_MULTICAST_BASE_ADDRESS.getLong();//33:33:00:00:00:00
+        macLong = macLong | ipLong;
+        MacAddress returnMac = MacAddress.of(macLong);
+
+        return returnMac;
+    }
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFAuxId.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFAuxId.java
index c8e04d2..3c83f91 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFAuxId.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFAuxId.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -64,11 +64,11 @@
         return id;
     }
 
-    public void writeByte(ChannelBuffer c) {
+    public void writeByte(ByteBuf c) {
         c.writeByte(this.id);
     }
 
-    public static OFAuxId readByte(ChannelBuffer c) throws OFParseError {
+    public static OFAuxId readByte(ByteBuf c) throws OFParseError {
         return OFAuxId.of(c.readUnsignedByte());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask128.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask128.java
index 93f5a2d..93ba41e 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask128.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask128.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 
@@ -66,12 +66,12 @@
         return (word & ((long)1 << bit)) != 0;
     }
 
-    public void write16Bytes(ChannelBuffer cb) {
+    public void write16Bytes(ByteBuf cb) {
         cb.writeLong(raw1);
         cb.writeLong(raw2);
     }
 
-    public static OFBitMask128 read16Bytes(ChannelBuffer cb) {
+    public static OFBitMask128 read16Bytes(ByteBuf cb) {
         long raw1 = cb.readLong();
         long raw2 = cb.readLong();
         return of(raw1, raw2);
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask256.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask256.java
index 5326e0d..6009a2f 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask256.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask256.java
@@ -17,7 +17,7 @@
 
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 
@@ -110,14 +110,14 @@
         return (word & ((long)1 << bit)) != 0;
     }
 
-    public void write32Bytes(ChannelBuffer cb) {
+    public void write32Bytes(ByteBuf cb) {
         cb.writeLong(raw1);
         cb.writeLong(raw2);
         cb.writeLong(raw3);
         cb.writeLong(raw4);
     }
 
-    public static OFBitMask256 read32Bytes(ChannelBuffer cb) {
+    public static OFBitMask256 read32Bytes(ByteBuf cb) {
         long raw1 = cb.readLong();
         long raw2 = cb.readLong();
         long raw3 = cb.readLong();
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask512.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask512.java
index e3686a4..39b8fe7 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask512.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBitMask512.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 
@@ -125,7 +125,7 @@
         return (word & ((long)1 << bit)) != 0;
     }
 
-    public void write64Bytes(ChannelBuffer cb) {
+    public void write64Bytes(ByteBuf cb) {
         cb.writeLong(raw1);
         cb.writeLong(raw2);
         cb.writeLong(raw3);
@@ -136,7 +136,7 @@
         cb.writeLong(raw8);
     }
 
-    public static OFBitMask512 read64Bytes(ChannelBuffer cb) {
+    public static OFBitMask512 read64Bytes(ByteBuf cb) {
         long raw1 = cb.readLong();
         long raw2 = cb.readLong();
         long raw3 = cb.readLong();
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBooleanValue.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBooleanValue.java
index 99416a3..7598d36 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBooleanValue.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFBooleanValue.java
@@ -17,7 +17,7 @@
 
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMessageReader;
 import org.projectfloodlight.openflow.protocol.Writeable;
@@ -79,13 +79,13 @@
     }
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         bb.writeByte(getInt());
     }
 
     private static class Reader implements OFMessageReader<OFBooleanValue> {
         @Override
-        public OFBooleanValue readFrom(ChannelBuffer bb) throws OFParseError {
+        public OFBooleanValue readFrom(ByteBuf bb) throws OFParseError {
             return of(bb.readByte() != 0);
         }
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFConnectionIndex.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFConnectionIndex.java
new file mode 100644
index 0000000..133f478
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFConnectionIndex.java
@@ -0,0 +1,78 @@
+package org.projectfloodlight.openflow.types;
+
+import org.projectfloodlight.openflow.annotations.Immutable;
+
+import com.google.common.hash.PrimitiveSink;
+import com.google.common.primitives.UnsignedInts;
+
+import io.netty.buffer.ByteBuf;
+
+@Immutable
+public class OFConnectionIndex implements OFValueType<OFConnectionIndex>  {
+
+    static final int LENGTH = 4;
+    private final int connectionIndex;
+
+    private OFConnectionIndex(final int connectionIndex) {
+        this.connectionIndex = connectionIndex;
+    }
+
+    public static OFConnectionIndex of(final int connectionIndex) {
+        return new OFConnectionIndex(connectionIndex);
+    }
+
+    public void write4Bytes(ByteBuf c) {
+        c.writeInt(connectionIndex);
+    }
+
+    public static OFConnectionIndex read4Bytes(ByteBuf c) {
+        return OFConnectionIndex.of(c.readInt());
+    }
+
+    @Override
+    public OFConnectionIndex applyMask(OFConnectionIndex mask) {
+        return OFConnectionIndex.of(this.connectionIndex & mask.connectionIndex);
+    }
+
+    @Override
+    public int compareTo(OFConnectionIndex o) {
+        return UnsignedInts.compare(this.connectionIndex,o.connectionIndex);
+    }
+
+    @Override
+    public void putTo(PrimitiveSink sink) {
+        sink.putInt(connectionIndex);
+    }
+
+    @Override
+    public int getLength() {
+        return LENGTH;
+    }
+
+    @Override
+    public String toString() {
+        return UnsignedInts.toString(connectionIndex);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + connectionIndex;
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        OFConnectionIndex other = (OFConnectionIndex) obj;
+        if (connectionIndex != other.connectionIndex)
+            return false;
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFErrorCauseData.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFErrorCauseData.java
index 1e71b3c..03e2fcd 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFErrorCauseData.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFErrorCauseData.java
@@ -1,9 +1,10 @@
 package org.projectfloodlight.openflow.types;
 
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+
 import java.util.Arrays;
 
-import org.jboss.netty.buffer.ChannelBuffer;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFErrorMsg;
 import org.projectfloodlight.openflow.protocol.OFFactories;
@@ -55,7 +56,7 @@
     public Optional<OFMessage> getParsedMessage() {
         OFFactory factory = OFFactories.getFactory(version);
         try {
-            OFMessage msg = factory.getReader().readFrom(ChannelBuffers.wrappedBuffer(data));
+            OFMessage msg = factory.getReader().readFrom(Unpooled.wrappedBuffer(data));
             if(msg != null)
                 return Optional.of(msg);
             else
@@ -66,7 +67,7 @@
         }
     }
 
-    public static OFErrorCauseData read(ChannelBuffer bb, int length, OFVersion version) {
+    public static OFErrorCauseData read(ByteBuf bb, int length, OFVersion version) {
         byte[] bytes = ChannelUtils.readBytes(bb, length);
         return of(bytes, version);
    }
@@ -77,7 +78,7 @@
     }
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         bb.writeBytes(data);
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFGroup.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFGroup.java
index 9c571ea..e47cd90 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFGroup.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFGroup.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.annotations.Immutable;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
@@ -79,7 +79,11 @@
         }
     }
 
-    /** return the group number as a int32 */
+    /** 
+     * get the group number of this group as a int32 
+     *
+     * @return the integer form of the this group
+     */
     public int getGroupNumber() {
         return groupNumber;
     }
@@ -131,11 +135,11 @@
         return result;
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(this.groupNumber);
     }
 
-    public static OFGroup read4Bytes(ChannelBuffer c) throws OFParseError {
+    public static OFGroup read4Bytes(ByteBuf c) throws OFParseError {
         return OFGroup.of(c.readInt());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFMetadata.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFMetadata.java
index fcabdcd..445c333 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFMetadata.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFMetadata.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 
@@ -31,11 +31,11 @@
         return u64;
     }
 
-    public static OFMetadata read8Bytes(ChannelBuffer cb) {
+    public static OFMetadata read8Bytes(ByteBuf cb) {
         return OFMetadata.ofRaw(cb.readLong());
     }
 
-    public void write8Bytes(ChannelBuffer cb) {
+    public void write8Bytes(ByteBuf cb) {
         u64.writeTo(cb);
     }
 
@@ -66,7 +66,7 @@
 
     @Override
     public String toString() {
-        return "Metadata: " + u64.toString();
+        return u64.toString();
     }
 
     @Override
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPort.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPort.java
index f2b1e9a..89ace97 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPort.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPort.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.annotations.Immutable;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
@@ -161,7 +161,7 @@
      * NOTE: The port object may either be newly allocated or cached. Do not
      * rely on either behavior.
      *
-     * @param portNumber
+     * @param portNumber the integer port number
      * @return a corresponding OFPort
      */
     public static OFPort ofInt(final int portNumber) {
@@ -294,7 +294,12 @@
         }
     }
 
-    /** convenience function: delegates to ofInt */
+    /** 
+     * convenience function: delegates to ofInt 
+     *
+     * @param portNumber the integer port number
+     * @return a corresponding OFPort
+     */
     public static OFPort of(final int portNumber) {
         return ofInt(portNumber);
     }
@@ -305,7 +310,7 @@
      * 32-bit integer value allocated as its port number. NOTE: The port object
      * may either be newly allocated or cached. Do not rely on either behavior.
      *
-     * @param portNumber
+     * @param portNumber the short port number
      * @return a corresponding OFPort
      */
     public static OFPort ofShort(final short portNumber) {
@@ -438,7 +443,11 @@
         }
     }
 
-    /** return the port number as a int32 */
+    /** 
+     * return the port number as a int32 
+     *
+     * @return the port number as an integer
+     */
     public int getPortNumber() {
         return portNumber;
     }
@@ -450,7 +459,8 @@
      *
      * @throws IllegalArgumentException
      *             if a regular port number exceeds the maximum value in OF1.0
-     **/
+     * @return the port number as a short
+     */
     public short getShortPortNumber() {
 
         switch (portNumber) {
@@ -530,19 +540,19 @@
         return result;
     }
 
-    public void write2Bytes(ChannelBuffer c) {
+    public void write2Bytes(ByteBuf c) {
         c.writeShort(this.portNumber);
     }
 
-    public static OFPort read2Bytes(ChannelBuffer c) throws OFParseError {
+    public static OFPort read2Bytes(ByteBuf c) throws OFParseError {
         return OFPort.ofShort(c.readShort());
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(this.portNumber);
     }
 
-    public static OFPort read4Bytes(ChannelBuffer c) throws OFParseError {
+    public static OFPort read4Bytes(ByteBuf c) throws OFParseError {
         return OFPort.of((int)(c.readUnsignedInt() & 0xFFFFFFFF));
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPortBitMap.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPortBitMap.java
index 1d658c5..1c3bc68 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPortBitMap.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPortBitMap.java
@@ -46,9 +46,13 @@
         super(OFBitMask128.NONE, mask);
     }
 
-    /** @return whether or not the given port is logically included in the
-     *  match, i.e., whether a packet from in-port <em>port</em> be matched by
-     *  this OXM.
+    /** 
+     * Check if the given port is logically included in the
+     * match. I.e. will a packet from in-port <em>port</em>
+     * be matched by this OXM?
+     *
+     * @param port the port to check in the match
+     * @return boolean true or false
      */
     public boolean isOn(OFPort port) {
         // see the implementation note above about the logical inversion of the mask
@@ -63,16 +67,19 @@
         return builder.build();
     }
 
-    /** @return an OFPortBitmap based on the 'mask' part of an OFBitMask128, as, e.g., returned
-     *  by the switch.
-     **/
+    /** 
+     * @param mask the mask to create the bitmap from
+     * @return an OFPortBitmap based on the 'mask' part of an OFBitMask128, as, e.g., returned
+     * by the switch.
+     */
     public static OFPortBitMap of(OFBitMask128 mask) {
         return new OFPortBitMap(mask);
     }
 
-    /** @return iterating over all ports that are logically included in the
-     *  match, i.e., whether a packet from in-port <em>port</em> be matched by
-     *  this OXM.
+    /** 
+     * @return iterating over all ports that are logically included in the
+     * match, i.e., whether a packet from in-port <em>port</em> be matched by
+     * this OXM.
      */
     public Iterable<OFPort> getOnPorts() {
         ArrayList<OFPort> ports = new ArrayList<>();
@@ -104,17 +111,22 @@
 
         }
 
-        /** @return whether or not the given port is logically included in the
-         *  match, i.e., whether a packet from in-port <em>port</em> be matched by
-         *  this OXM.
+        /** 
+         * @param port the port to check if it's being matched by the bitmask
+         * @return whether or not the given port is logically included in the
+         * match, i.e., whether a packet from in-port <em>port</em> be matched by
+         * this OXM.
          */
         public boolean isOn(OFPort port) {
             // see the implementation note above about the logical inversion of the mask
             return !(OFBitMask128.isBitOn(raw1, raw2, port.getPortNumber()));
         }
 
-        /** remove this port from the match, i.e., packets from this in-port
-         *  will NOT be matched.
+        /** 
+         * remove this port from the match, i.e., packets from this in-port
+         * will NOT be matched.
+         * @param port the port to remove from the match
+         * @return this mutator
          */
         public Builder unset(OFPort port) {
             // see the implementation note above about the logical inversion of the mask
@@ -135,8 +147,11 @@
             return this;
         }
 
-        /** add this port from the match, i.e., packets from this in-port
-         *  will NOT be matched.
+        /** 
+         * add this port to the match, i.e., packets from this in-port
+         * will be matched.
+         * @param port the port to add to the match
+         * @return this mutator 
          */
         public Builder set(OFPort port) {
             // see the implementation note above about the logical inversion of the mask
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPortBitMap512.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPortBitMap512.java
index c85c750..e9c8f4c 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPortBitMap512.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFPortBitMap512.java
@@ -46,9 +46,11 @@
         super(OFBitMask512.NONE, mask);
     }
 
-    /** @return whether or not the given port is logically included in the
-     *  match, i.e., whether a packet from in-port <em>port</em> be matched by
-     *  this OXM.
+    /** 
+     * @param port the port to check
+     * @return whether or not the given port is logically included in the
+     * match, i.e., whether a packet from in-port <em>port</em> be matched by
+     * this OXM.
      */
     public boolean isOn(OFPort port) {
         // see the implementation note above about the logical inversion of the mask
@@ -63,16 +65,19 @@
         return builder.build();
     }
 
-    /** @return an OFPortBitmap based on the 'mask' part of an OFBitMask512, as, e.g., returned
-     *  by the switch.
-     **/
+    /** 
+     * @param mask the mask used to create the bitmap
+     * @return an OFPortBitmap based on the 'mask' part of an OFBitMask512, as, e.g., returned
+     * by the switch.
+     */
     public static OFPortBitMap512 of(OFBitMask512 mask) {
         return new OFPortBitMap512(mask);
     }
 
-    /** @return iterating over all ports that are logically included in the
-     *  match, i.e., whether a packet from in-port <em>port</em> be matched by
-     *  this OXM.
+    /** 
+     * @return iterating over all ports that are logically included in the
+     * match, i.e., whether a packet from in-port <em>port</em> be matched by
+     * this OXM.
      */
     public Iterable<OFPort> getOnPorts() {
         ArrayList<OFPort> ports = new ArrayList<>();
@@ -105,9 +110,11 @@
 
         }
 
-        /** @return whether or not the given port is logically included in the
-         *  match, i.e., whether a packet from in-port <em>port</em> be matched by
-         *  this OXM.
+        /**
+         * @param port the port to check
+         * @return whether or not the given port is logically included in the
+         * match, i.e., whether a packet from in-port <em>port</em> be matched by
+         * this OXM.
          */
         public boolean isOn(OFPort port) {
             // see the implementation note above about the logical inversion of the mask
@@ -115,8 +122,11 @@
                     raw5, raw6, raw7, raw8, port.getPortNumber()));
         }
 
-        /** remove this port from the match, i.e., packets from this in-port
-         *  will NOT be matched.
+        /** 
+         * remove this port from the match, i.e., packets from this in-port
+         * will NOT be matched.
+         * @param port the port the remove from the match
+         * @return this mutator
          */
         public Builder unset(OFPort port) {
             // see the implementation note above about the logical inversion of the mask
@@ -149,8 +159,11 @@
             return this;
         }
 
-        /** add this port from the match, i.e., packets from this in-port
-         *  will NOT be matched.
+        /**
+         * add this port from the match, i.e., packets from this in-port
+         * will be matched.
+         * @param port the port to add to the match
+         * @return this mutator
          */
         public Builder set(OFPort port) {
             // see the implementation note above about the logical inversion of the mask
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFVlanVidMatch.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFVlanVidMatch.java
index 91c9fc8..de9da67 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFVlanVidMatch.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OFVlanVidMatch.java
@@ -4,7 +4,7 @@
 
 import javax.annotation.Nullable;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -48,7 +48,7 @@
     /** an untagged packet is specified as 0000 in OF 1.0, but 0xFFFF in OF1.0. Special case that. */
     public static final OFVlanVidMatch UNTAGGED = new OFVlanVidMatch(NONE_VAL) {
         @Override
-        public void write2BytesOF10(ChannelBuffer c) {
+        public void write2BytesOF10(ByteBuf c) {
             c.writeShort(UNTAGGED_VAL_OF10);
         }
     };
@@ -172,19 +172,19 @@
         return Arrays.copyOf(bytesCache, bytesCache.length);
     }
 
-    public void write2Bytes(ChannelBuffer c) {
+    public void write2Bytes(ByteBuf c) {
         c.writeShort(this.vid);
     }
 
-    public void write2BytesOF10(ChannelBuffer c) {
+    public void write2BytesOF10(ByteBuf c) {
         c.writeShort(this.getVlan());
     }
 
-    public static OFVlanVidMatch read2Bytes(ChannelBuffer c) throws OFParseError {
+    public static OFVlanVidMatch read2Bytes(ByteBuf c) throws OFParseError {
         return OFVlanVidMatch.ofRawVid(c.readShort());
     }
 
-    public static OFVlanVidMatch read2BytesOF10(ChannelBuffer c) throws OFParseError {
+    public static OFVlanVidMatch read2BytesOF10(ByteBuf c) throws OFParseError {
         return OFVlanVidMatch.ofVlanOF10(c.readShort());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OduSignalID.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OduSignalID.java
index c97c4d0..97a5d0d 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OduSignalID.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/OduSignalID.java
@@ -18,7 +18,7 @@
 
 import java.util.List;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.collect.ComparisonChain;
 import com.google.common.primitives.UnsignedBytes;
@@ -75,14 +75,14 @@
       return MINIMUM_LENGTH + 12; //  tslen == 80 
     }
  
-    public void writeTo(ChannelBuffer c) {
+    public void writeTo(ByteBuf c) {
         c.writeShort(tpn);
         c.writeShort(tslen);
         c.writeBytes(tsmap); // 10 bytes
         c.writeZero(2); // write bytes for add padding alignment (the size of bytes in tsmap must be divided in 4)   
     }
 
-     public static OduSignalID readFrom(ChannelBuffer c)   {
+     public static OduSignalID readFrom(ByteBuf c)   {
         int tpn = U16.f(c.readShort());
         int tslen = U16.f(c.readShort());
         byte[] tsmap = null;
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/PacketType.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/PacketType.java
new file mode 100644
index 0000000..3881b63
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/PacketType.java
@@ -0,0 +1,143 @@
+package org.projectfloodlight.openflow.types;
+
+import org.projectfloodlight.openflow.protocol.OFHeaderTypeNamespace;
+
+import com.google.common.hash.PrimitiveSink;
+import com.google.common.primitives.UnsignedInts;
+
+import io.netty.buffer.ByteBuf;
+
+public class PacketType implements OFValueType<PacketType> {
+
+    private final int namespace;
+    private final int nsType;
+
+    static final int NAMESPACE_ONF = 0;
+    static final int NAMESPACE_ETHERTYPE = 1;
+
+    static final int NS_TYPE_ONF_ETHERNET = 0;
+    static final int NS_TYPE_ONF_NO_PACKET = 1;
+    static final int NS_TYPE_ONF_EXPERIMENTER   = 0xFFFF;
+
+    static final int NS_TYPE_ETHER_IPv4   = 0x800;
+    static final int NS_TYPE_ETHER_IPv6   = 0x86dd;
+
+    public static final PacketType ETHERNET = new PacketType(NAMESPACE_ONF, NS_TYPE_ONF_ETHERNET);
+    public static final PacketType NO_PACKET = new PacketType(NAMESPACE_ONF, NS_TYPE_ONF_NO_PACKET);
+    public static final PacketType EXPERIMENTER = new PacketType(NAMESPACE_ONF, NS_TYPE_ONF_EXPERIMENTER);
+
+    public static final PacketType IPV4 = new PacketType(NAMESPACE_ETHERTYPE, NS_TYPE_ETHER_IPv4);
+    public static final PacketType IPV6 = new PacketType(NAMESPACE_ETHERTYPE, NS_TYPE_ETHER_IPv6);
+
+    public static final PacketType NO_MASK = PacketType.of(0xFFFF, 0x0FFFF);
+    public static final PacketType FULL_MASK = PacketType.of(0, 0);
+
+    private PacketType(int namespace, int nsType) {
+        this.namespace = namespace;
+        this.nsType = nsType;
+    }
+
+    public static PacketType of(int namespace, int nsType) {
+        switch(namespace) {
+            case NAMESPACE_ONF:
+                switch (nsType) {
+                    case NS_TYPE_ONF_ETHERNET:
+                        return ETHERNET;
+                    case NS_TYPE_ONF_NO_PACKET:
+                        return NO_PACKET;
+                    case NS_TYPE_ONF_EXPERIMENTER:
+                        return EXPERIMENTER;
+                }
+                break;
+            case NAMESPACE_ETHERTYPE:
+                switch (nsType) {
+                    case NS_TYPE_ETHER_IPv4:
+                        return IPV4;
+                    case NS_TYPE_ETHER_IPv6:
+                        return IPV6;
+                }
+                break;
+        }
+        return new PacketType(namespace, nsType);
+    }
+
+    public static PacketType of(OFHeaderTypeNamespace namespace, int nsType) {
+        return of(namespace.getStableValue(), nsType);
+
+    }
+
+    @Override
+    public PacketType applyMask(PacketType mask) {
+        return PacketType.of(this.namespace & mask.namespace, this.nsType & mask.nsType);
+    }
+
+    @Override
+    public int compareTo(PacketType o) {
+        int res = UnsignedInts.compare(this.namespace, o.namespace);
+        if(res != 0)
+            return res;
+
+        return UnsignedInts.compare(this.nsType, o.nsType);
+    }
+
+    @Override
+    public void putTo(PrimitiveSink sink) {
+        sink.putInt(namespace);
+        sink.putInt(nsType);
+    }
+
+    @Override
+    public int getLength() {
+        //4 byte
+        return 4;
+    }
+
+    public void write4Bytes(ByteBuf c) {
+        c.writeShort(namespace);
+        c.writeInt(nsType);
+    }
+
+    public static PacketType read4Bytes(ByteBuf c) {
+        return PacketType.of(c.readShort(), c.readInt());
+    }
+
+    public int getNamespace() {
+        return namespace;
+    }
+
+    public int getNsType() {
+        return nsType;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + namespace;
+        result = prime * result + nsType;
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        PacketType other = (PacketType) obj;
+        if (namespace != other.namespace)
+            return false;
+        if (nsType != other.nsType)
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "PacketType [namespace=" + namespace + ", nsType=" + nsType + "]";
+    }
+
+
+}
\ No newline at end of file
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/TableId.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/TableId.java
index 950087d..5519d4e 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/TableId.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/TableId.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -58,11 +58,11 @@
         return LENGTH;
     }
 
-    public void writeByte(ChannelBuffer c) {
+    public void writeByte(ByteBuf c) {
         c.writeByte(this.id);
     }
 
-    public static TableId readByte(ChannelBuffer c) throws OFParseError {
+    public static TableId readByte(ByteBuf c) throws OFParseError {
         return TableId.of(c.readUnsignedByte());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/TransportPort.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/TransportPort.java
index 6ab0254..bfca2d7 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/TransportPort.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/TransportPort.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -72,11 +72,11 @@
         return Integer.toString(port);
     }
 
-    public void write2Bytes(ChannelBuffer c) {
+    public void write2Bytes(ByteBuf c) {
         c.writeShort(this.port);
     }
 
-    public static TransportPort read2Bytes(ChannelBuffer c) throws OFParseError {
+    public static TransportPort read2Bytes(ByteBuf c) throws OFParseError {
         return TransportPort.of((c.readUnsignedShort() & 0x0FFFF));
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U128.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U128.java
index ddf4faa..9e7bd34 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U128.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U128.java
@@ -2,7 +2,7 @@
 
 import javax.annotation.Nonnull;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedLongs;
@@ -71,12 +71,12 @@
         return true;
     }
 
-    public void write16Bytes(ChannelBuffer cb) {
+    public void write16Bytes(ByteBuf cb) {
         cb.writeLong(raw1);
         cb.writeLong(raw2);
     }
 
-    public static U128 read16Bytes(ChannelBuffer cb) {
+    public static U128 read16Bytes(ByteBuf cb) {
         long raw1 = cb.readLong();
         long raw2 = cb.readLong();
         return of(raw1, raw2);
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U16.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U16.java
index 2466ffc..9ed0f45 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U16.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U16.java
@@ -17,7 +17,7 @@
 
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMessageReader;
 import org.projectfloodlight.openflow.protocol.Writeable;
@@ -94,7 +94,7 @@
 
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         bb.writeShort(raw);
     }
 
@@ -103,7 +103,7 @@
 
     private static class Reader implements OFMessageReader<U16> {
         @Override
-        public U16 readFrom(ChannelBuffer bb) throws OFParseError {
+        public U16 readFrom(ByteBuf bb) throws OFParseError {
             return ofRaw(bb.readShort());
         }
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U32.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U32.java
index c69786c..fddb647 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U32.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U32.java
@@ -17,7 +17,7 @@
 
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMessageReader;
 import org.projectfloodlight.openflow.protocol.Writeable;
@@ -96,7 +96,7 @@
     }
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         bb.writeInt(raw);
     }
 
@@ -104,7 +104,7 @@
 
     private static class Reader implements OFMessageReader<U32> {
         @Override
-        public U32 readFrom(ChannelBuffer bb) throws OFParseError {
+        public U32 readFrom(ByteBuf bb) throws OFParseError {
             return new U32(bb.readInt());
         }
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U64.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U64.java
index f15544f..0d3cc6e 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U64.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U64.java
@@ -19,7 +19,7 @@
 
 import java.math.BigInteger;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMessageReader;
 import org.projectfloodlight.openflow.protocol.Writeable;
@@ -118,7 +118,7 @@
     }
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         bb.writeLong(raw);
     }
 
@@ -174,7 +174,7 @@
 
     private static class Reader implements OFMessageReader<U64> {
         @Override
-        public U64 readFrom(ChannelBuffer bb) throws OFParseError {
+        public U64 readFrom(ByteBuf bb) throws OFParseError {
             return U64.ofRaw(bb.readLong());
         }
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U8.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U8.java
index 17191af..f4fed56 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U8.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/U8.java
@@ -17,7 +17,7 @@
 
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMessageReader;
 import org.projectfloodlight.openflow.protocol.Writeable;
@@ -89,7 +89,7 @@
 
 
     @Override
-    public void writeTo(ChannelBuffer bb) {
+    public void writeTo(ByteBuf bb) {
         bb.writeByte(raw);
     }
 
@@ -106,7 +106,7 @@
 
     private static class Reader implements OFMessageReader<U8> {
         @Override
-        public U8 readFrom(ChannelBuffer bb) throws OFParseError {
+        public U8 readFrom(ByteBuf bb) throws OFParseError {
             return new U8(bb.readByte());
         }
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/UDF.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/UDF.java
index e537c20..bc43d56 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/UDF.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/UDF.java
@@ -2,7 +2,7 @@
 
 import javax.annotation.concurrent.Immutable;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedInts;
@@ -60,11 +60,11 @@
         return Integer.toString(rawValue);
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(rawValue);
     }
 
-    public static UDF read4Bytes(ChannelBuffer c) {
+    public static UDF read4Bytes(ByteBuf c) {
         return UDF.of(c.readInt());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VFI.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VFI.java
new file mode 100644
index 0000000..07691ee
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VFI.java
@@ -0,0 +1,93 @@
+package org.projectfloodlight.openflow.types;
+
+import io.netty.buffer.ByteBuf;
+
+import org.projectfloodlight.openflow.exceptions.OFParseError;
+
+import com.google.common.hash.PrimitiveSink;
+
+/** Represents a two byte virtual forwarding instance.
+*
+* @author Sudeep Modi {@literal <}sudeep.modi@bigswitch.com{@literal >}
+*
+*/public class VFI implements OFValueType<VFI> {
+    private static final short ZERO_VAL = 0x0000;
+    final static int LENGTH = 2;
+
+    public static final VFI ZERO = new VFI(ZERO_VAL);
+
+    /** for use with masking operations */
+    public static final VFI NO_MASK = new VFI((short)0xFFFF);
+    public static final VFI FULL_MASK = ZERO;
+
+    private final short vfi;
+
+    private VFI(short vfi) {
+        this.vfi = vfi;
+    }
+
+    public static VFI ofVfi(int vfi) {
+        if (vfi == NO_MASK.vfi)
+            return NO_MASK;
+        if (vfi == ZERO_VAL)
+            return ZERO;
+        return new VFI((short) vfi);
+    }
+
+    /** @return the actual VFI value */
+    public short getVfi() {
+        return vfi;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + vfi;
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null) return false;
+        if (getClass() != obj.getClass()) return false;
+        VFI other = (VFI) obj;
+        if (vfi != other.vfi) return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "0x" + Integer.toHexString(vfi);
+    }
+
+    @Override
+    public int getLength() {
+        return LENGTH;
+    }
+
+    public void write2Bytes(ByteBuf c) {
+        c.writeShort(this.vfi);
+    }
+
+    public static VFI read2Bytes(ByteBuf c) throws OFParseError {
+        return VFI.ofVfi(c.readShort());
+    }
+
+    @Override
+    public VFI applyMask(VFI mask) {
+        return VFI.ofVfi(this.vfi & mask.vfi);
+    }
+
+    @Override
+    public int compareTo(VFI o) {
+        return Integer.compare(vfi & 0xffff, o.vfi & 0xffff);
+    }
+
+    @Override
+    public void putTo(PrimitiveSink sink) {
+        sink.putShort(vfi);
+    }
+
+}
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VRF.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VRF.java
index b742da5..ad57e7d 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VRF.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VRF.java
@@ -2,7 +2,7 @@
 
 import javax.annotation.concurrent.Immutable;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 import com.google.common.hash.PrimitiveSink;
 import com.google.common.primitives.UnsignedInts;
@@ -60,11 +60,11 @@
         return Integer.toString(rawValue);
     }
 
-    public void write4Bytes(ChannelBuffer c) {
+    public void write4Bytes(ByteBuf c) {
         c.writeInt(rawValue);
     }
 
-    public static VRF read4Bytes(ChannelBuffer c) {
+    public static VRF read4Bytes(ByteBuf c) {
         return VRF.of(c.readInt());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VlanPcp.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VlanPcp.java
index cbb7004..5ec25dc 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VlanPcp.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VlanPcp.java
@@ -1,6 +1,6 @@
 package org.projectfloodlight.openflow.types;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -58,11 +58,11 @@
         return LENGTH;
     }
 
-    public void writeByte(ChannelBuffer c) {
+    public void writeByte(ByteBuf c) {
         c.writeByte(this.pcp);
     }
 
-    public static VlanPcp readByte(ChannelBuffer c) throws OFParseError {
+    public static VlanPcp readByte(ByteBuf c) throws OFParseError {
         return VlanPcp.of((byte)(c.readUnsignedByte() & 0xFF));
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VlanVid.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VlanVid.java
index 1c3eba4..a842821 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VlanVid.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VlanVid.java
@@ -1,8 +1,9 @@
 package org.projectfloodlight.openflow.types;
 
+import io.netty.buffer.ByteBuf;
+
 import java.util.Arrays;
 
-import org.jboss.netty.buffer.ChannelBuffer;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
 import com.google.common.hash.PrimitiveSink;
@@ -86,15 +87,15 @@
         return Arrays.copyOf(bytesCache, bytesCache.length);
     }
 
-    public void write2Bytes(ChannelBuffer c) {
+    public void write2Bytes(ByteBuf c) {
         c.writeShort(this.vid);
     }
 
-    public void write2BytesOF10(ChannelBuffer c) {
+    public void write2BytesOF10(ByteBuf c) {
         c.writeShort(this.getVlan());
     }
 
-    public static VlanVid read2Bytes(ChannelBuffer c) throws OFParseError {
+    public static VlanVid read2Bytes(ByteBuf c) throws OFParseError {
         return VlanVid.ofVlan(c.readShort());
     }
 
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VxlanNI.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VxlanNI.java
new file mode 100644
index 0000000..5e52b5c
--- /dev/null
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/types/VxlanNI.java
@@ -0,0 +1,98 @@
+package org.projectfloodlight.openflow.types;
+
+import org.projectfloodlight.openflow.exceptions.OFParseError;
+
+import com.google.common.hash.PrimitiveSink;
+import com.google.common.primitives.UnsignedInts;
+
+import io.netty.buffer.ByteBuf;
+
+/** Represents the VXLAN Network Identifier (24 bits).
+ *
+ * @author Sarath Kumar Sankaran Kutty
+ * {@literal <}sarath.kutty@bigswitch.com{@literal >}
+ */
+public class VxlanNI implements OFValueType<VxlanNI> {
+
+    private static final int VALIDATION_MASK = 0x00FFffFF;
+    final static int LENGTH = 4;
+
+    private static final int ZERO_VAL = 0x0;
+    public static final VxlanNI ZERO = new VxlanNI(ZERO_VAL);
+
+    private static final int NO_MASK_VAL = 0xFFffFFff;
+    public final static VxlanNI NO_MASK = new VxlanNI(NO_MASK_VAL);
+    public static final VxlanNI FULL_MASK = ZERO;
+
+    private final int vni;
+
+    private VxlanNI(int vni) {
+        this.vni = vni;
+    }
+
+    public static VxlanNI ofVni(int vni) {
+        if (vni == ZERO_VAL)
+            return ZERO;
+        if ((vni & VALIDATION_MASK) != vni) {
+            throw new IllegalArgumentException(String.format("Illegal VNI value: %x", vni));
+        }
+        return new VxlanNI(vni);
+    }
+
+    /** @return the VxLAN Network ID */
+    public int getVni() {
+        return vni;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null) return false;
+        if (getClass() != obj.getClass()) return false;
+        VxlanNI other = (VxlanNI) obj;
+        if (vni != other.vni) return false;
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + vni;
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(vni);
+    }
+
+    @Override
+    public int getLength() {
+        return LENGTH;
+    }
+
+
+    public void write4Bytes(ByteBuf c) {
+        c.writeInt(this.vni);
+    }
+
+    public static VxlanNI read4Bytes(ByteBuf c) throws OFParseError {
+        return VxlanNI.ofVni(c.readInt());
+    }
+
+    @Override
+    public VxlanNI applyMask(VxlanNI mask) {
+        return VxlanNI.ofVni(this.vni & mask.vni);
+    }
+
+    @Override
+    public int compareTo(VxlanNI o) {
+        return UnsignedInts.compare(vni, o.vni);
+    }
+
+    @Override
+    public void putTo(PrimitiveSink sink) {
+        sink.putInt(vni);
+    }
+}
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/ChannelUtils.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/ChannelUtils.java
index 1a1ac6a..93d7ba6 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/ChannelUtils.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/ChannelUtils.java
@@ -2,7 +2,7 @@
 
 import java.util.List;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 import org.projectfloodlight.openflow.protocol.OFMessageReader;
 import org.projectfloodlight.openflow.protocol.Writeable;
@@ -14,14 +14,15 @@
 import com.google.common.collect.ImmutableList.Builder;
 
 /**
- * Collection of helper functions for reading and writing into ChannelBuffers
+ * Collection of helper functions for reading and writing into Unpooled
  *
  * @author capveg
  */
 
 public class ChannelUtils {
     private static final Logger logger = LoggerFactory.getLogger(ChannelUtils.class);
-    public static String readFixedLengthString(ChannelBuffer bb, int length) {
+
+    public static String readFixedLengthString(ByteBuf bb, int length) {
         byte[] dst = new byte[length];
         bb.readBytes(dst, 0, length);
         int validLength = 0;
@@ -32,7 +33,7 @@
         return new String(dst, 0, validLength, Charsets.US_ASCII);
     }
 
-    public static void writeFixedLengthString(ChannelBuffer bb, String string,
+    public static void writeFixedLengthString(ByteBuf bb, String string,
             int length) {
         int l = string.length();
         if (l > length) {
@@ -45,18 +46,18 @@
         }
     }
 
-    static public byte[] readBytes(final ChannelBuffer bb, final int length) {
+    static public byte[] readBytes(final ByteBuf bb, final int length) {
         byte byteArray[] = new byte[length];
         bb.readBytes(byteArray);
         return byteArray;
     }
 
-    static public void writeBytes(final ChannelBuffer bb,
+    static public void writeBytes(final ByteBuf bb,
             final byte byteArray[]) {
         bb.writeBytes(byteArray);
     }
 
-    public static <T> List<T> readList(ChannelBuffer bb, int length, OFMessageReader<T> reader) throws OFParseError {
+    public static <T> List<T> readList(ByteBuf bb, int length, OFMessageReader<T> reader) throws OFParseError {
         int end = bb.readerIndex() + length;
         Builder<T> builder = ImmutableList.<T>builder();
         if(logger.isTraceEnabled())
@@ -73,7 +74,7 @@
         return builder.build();
     }
 
-    public static void writeList(ChannelBuffer bb, List<? extends Writeable> writeables) {
+    public static void writeList(ByteBuf bb, List<? extends Writeable> writeables) {
         for(Writeable w: writeables)
             w.writeTo(bb);
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/HexString.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/HexString.java
index bcc46f7..00cc65e 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/HexString.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/HexString.java
@@ -1,70 +1,104 @@
-/**
- *    Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior
- *    University
- *
- *    Licensed under the Apache License, Version 2.0 (the "License"); you may
- *    not use this file except in compliance with the License. You may obtain
- *    a copy of the License at
- *
- *         http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- *    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- *    License for the specific language governing permissions and limitations
- *    under the License.
- **/
-
 package org.projectfloodlight.openflow.util;
 
-import org.projectfloodlight.openflow.types.U8;
+import io.netty.util.internal.EmptyArrays;
 
-public class HexString {
+/** Utility method to convert hexadecimal string from/to longs and byte arrays.
+ *
+ * @author Andreas Wundsam {@literal <}andreas.wundsam@bigswitch.com{@literal >}
+ */
+public final class HexString {
+
+    private HexString() {}
+
+    /* ================================================================================
+     * Implementation note:
+     * These implementations are optimized for small-O efficiency and thus rather ugly.
+     *
+     * When making changes, make sure *every line* is covered by a unit test.
+     *
+     * Do not use this as a blue print for normal code.
+     * ================================================================================
+     */
+
+    private final static char[] CHARS =
+        { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
     /**
      * Convert a string of bytes to a ':' separated hex string
      *
-     * @param bytes
+     * @param bytes the byte[] to convert
      * @return "0f:ca:fe:de:ad:be:ef"
      */
     public static String toHexString(final byte[] bytes) {
-        int i;
-        String ret = "";
-        String tmp;
-        for (i = 0; i < bytes.length; i++) {
-            if (i > 0)
-                ret += ":";
-            tmp = Integer.toHexString(U8.f(bytes[i]));
-            if (tmp.length() == 1)
-                ret += "0";
-            ret += tmp;
+        int lenBytes = bytes.length;
+        if (lenBytes == 0) {
+            return "";
         }
-        return ret;
+        char arr[] = new char[lenBytes * 2 + (lenBytes -1)];
+
+        int charPos = 0;
+        int i = 0;
+
+        for (;;) {
+            arr[charPos++] = CHARS[ (bytes[i] >>> 4) & 0xF ];
+            arr[charPos++] = CHARS[ bytes[i] & 0xF ];
+            if (++i >= lenBytes) {
+                break;
+            }
+            arr[charPos++] = ':';
+        }
+
+        return new String(arr, 0, arr.length);
     }
 
-    public static String toHexString(final long val, final int padTo) {
-        char arr[] = Long.toHexString(val).toCharArray();
-        String ret = "";
-        // prepend the right number of leading zeros
-        int i = 0;
-        for (; i < (padTo * 2 - arr.length); i++) {
-            ret += "0";
-            if ((i % 2) != 0)
-                ret += ":";
+    public static String toHexString(long val, final int padTo) {
+        int valBytes = (64 - Long.numberOfLeadingZeros(val) + 7)/8;
+        int lenBytes = valBytes > padTo ? valBytes : padTo;
+
+        char arr[] = new char[lenBytes * 2 + (lenBytes -1)];
+
+        // fill char array from the last position, shifting val by 4 bits
+        for (int charPos = arr.length - 1; charPos >= 0; charPos--) {
+            if ((charPos + 1) % 3 == 0) {
+                // every third char is a colon
+                arr[charPos] = ':';
+            } else {
+                arr[charPos] = CHARS[((int) val) & 0xF];
+                val >>>= 4;
+            }
         }
-        for (int j = 0; j < arr.length; j++) {
-            ret += arr[j];
-            if ((((i + j) % 2) != 0) && (j < (arr.length - 1)))
-                ret += ":";
-        }
-        return ret;
+        return new String(arr, 0, arr.length);
     }
 
     public static String toHexString(final long val) {
         return toHexString(val, 8);
     }
 
+
+    /** Deprecated version of {@link #toBytes(String)}.
+     *
+     * @throws NumberFormatException upon values parse error
+     * @param values the hexstring to parse into a byte[]
+     * @return a byte[] representing the hexstring
+     * {@link Deprecated} because of inconsistent naming
+     */
+    @Deprecated
+    public static byte[] fromHexString(final String values) throws NumberFormatException {
+        return toBytes(values);
+    }
+
+    /** state constants for toBytes */
+    /** expecting first digit */
+    private final static int FIRST_DIGIT = 1;
+    /** expecting second digit or colon */
+    private static final int SECOND_DIGIT_OR_COLON = 2;
+    /** expecting colon */
+    private static final int COLON = 3;
+    /** save byte and move back to FIRST_DIGIT */
+    private static final int SAVE_BYTE = 4;
+
     /**
-     * Convert a string of hex values into a string of bytes
+     * Convert a string of hex values into a string of bytes.
      *
      * @param values
      *            "0f:ca:fe:de:ad:be:ef"
@@ -72,29 +106,103 @@
      * @throws NumberFormatException
      *             If the string can not be parsed
      */
-    public static byte[] fromHexString(final String values) throws NumberFormatException {
-        String[] octets = values.split(":");
-        byte[] ret = new byte[octets.length];
+    public static byte[] toBytes(final String values) throws NumberFormatException {
+        int start = 0;
+        int len = values.length();
 
-        for (int i = 0; i < octets.length; i++) {
-            if (octets[i].length() > 2)
-                throw new NumberFormatException("Invalid octet length");
-            ret[i] = Integer.valueOf(octets[i], 16).byteValue();
+        if (len == 0) {
+            return EmptyArrays.EMPTY_BYTES;
         }
-        return ret;
+
+        int numColons = 0;
+        for (int i=0; i < len; i++) {
+            if (values.charAt(i) == ':') {
+                numColons++;
+            }
+        }
+
+        byte[] res = new byte[numColons+1];
+        int pos = 0;
+
+        int state = FIRST_DIGIT;
+
+        byte b = 0;
+        while (start < len) {
+            char c = values.charAt(start++);
+            switch (state) {
+                case FIRST_DIGIT:
+                    int digit = Character.digit(c, 16);
+                    if(digit < 0) {
+                        throw new NumberFormatException("Invalid char at index " + start + ": " + values);
+                    }
+                    b = (byte) digit;
+                    state = start < len ? SECOND_DIGIT_OR_COLON : SAVE_BYTE;
+                    break;
+                case SECOND_DIGIT_OR_COLON:
+                    if(c != ':') {
+                        int digit2 = Character.digit(c, 16);
+                        if(digit2 < 0) {
+                            throw new NumberFormatException("Invalid char at index " + start + ": " + values);
+                        }
+                        b =  (byte) ((b<<4) | digit2);
+                        state = start < len ? COLON : SAVE_BYTE;
+                    } else {
+                        state = SAVE_BYTE;
+                    }
+                    break;
+                case COLON:
+                    if(c != ':') {
+                        throw new NumberFormatException("Separator expected at index " + start + ": " + values);
+                    }
+                    state = SAVE_BYTE;
+                    break;
+                default:
+                    throw new IllegalStateException("Should not be in state " + state);
+            }
+            if (state == SAVE_BYTE) {
+                res[pos++] = b;
+                b = 0;
+                state = FIRST_DIGIT;
+            }
+        }
+        if (pos != res.length) {
+            // detects a mal-formed input string, e.g., "01:02:"
+            throw new NumberFormatException("Invalid hex string: " + values);
+        }
+
+        return res;
     }
 
     public static long toLong(String value) throws NumberFormatException {
-        String[] octets = value.split(":");
-        if (octets.length > 8)
-            throw new NumberFormatException("Input string is too big to fit in long: " + value);
-        long l = 0;
-        for (String octet: octets) {
-            if (octet.length() > 2)
-                throw new NumberFormatException("Each colon-separated byte component must consist of 1 or 2 hex digits: " + value);
-            short s = Short.parseShort(octet, 16);
-            l = (l << 8) + s;
+        int shift = 0;
+        long result = 0L;
+
+        int sinceLastSeparator = 0;
+        for (int charPos=value.length() - 1; charPos >= 0; charPos--) {
+            char c = value.charAt(charPos);
+            if (c == ':') {
+                if (sinceLastSeparator == 0) {
+                    throw new NumberFormatException("Expected hex digit at index " + charPos +": " + value);
+                } else if(sinceLastSeparator == 1) {
+                    shift += 4;
+                }
+                sinceLastSeparator = 0;
+            } else {
+                int digit = Character.digit(c, 16);
+                if (digit < 0) {
+                    throw new NumberFormatException("Invalid hex digit at index " + charPos +": " + value);
+                }
+                result |= ((long) digit) << shift;
+                shift +=4;
+                sinceLastSeparator++;
+                if (sinceLastSeparator > 2) {
+                    throw new NumberFormatException("Expected colon at index " + charPos +": " + value);
+                }
+            }
+            if (shift > 64) {
+                throw new NumberFormatException("Too many bytes in hex string to convert to long: " + value);
+            }
         }
-        return l;
+        return result;
     }
 }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/MultiplePktInReasonUtil.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/MultiplePktInReasonUtil.java
index 3ee588f..107b7cf 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/MultiplePktInReasonUtil.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/MultiplePktInReasonUtil.java
@@ -20,7 +20,10 @@
     /**
      * This function is used in BVS T5/6 to decode the multiple packet in
      * reasons in Match.MetaData field.
-     * */
+     *
+     * @param pktIn the packet in message
+     * @return the set of packet in reasons
+     */
     public static Set<OFBsnPktinFlag> getOFBsnPktinFlags(OFPacketIn pktIn) {
         if(pktIn.getVersion().compareTo(OFVersion.OF_13) < 0) {
             throw new IllegalArgumentException("multiple pkt in reasons are "
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/PrimitiveSinkUtils.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/PrimitiveSinkUtils.java
index aafe262..7b01e4c 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/PrimitiveSinkUtils.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/PrimitiveSinkUtils.java
@@ -48,8 +48,8 @@
     /** puts the elements of a sorted set into the {@link PrimitiveSink}. Does not support null
      *  elements. The elements are assumed to be self-delimitating.
      *
-     * @param sink
-     * @param set
+     * @param sink the sink to put the sorted set
+     * @param set the sorted set
      */
     public static void putSortedSetTo(PrimitiveSink sink,
             SortedSet<? extends PrimitiveSinkable> set) {
@@ -62,13 +62,13 @@
     /** puts the elements of a list into the {@link PrimitiveSink}. Does not support null
      *  elements. The elements are assumed to be self-delimitating.
      *
-     * @param sink
-     * @param set
+     * @param sink the sink to put the list elements
+     * @param list the list
      */
     public static void putListTo(PrimitiveSink sink,
-            List<? extends PrimitiveSinkable> set) {
-        sink.putInt(set.size());
-        for(PrimitiveSinkable e: set) {
+            List<? extends PrimitiveSinkable> list) {
+        sink.putInt(list.size());
+        for(PrimitiveSinkable e: list) {
             e.putTo(sink);
         }
     }
diff --git a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/StringByteSerializer.java b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/StringByteSerializer.java
index 6949fb2..6396f2e 100644
--- a/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/StringByteSerializer.java
+++ b/java_gen/pre-written/src/main/java/org/projectfloodlight/openflow/util/StringByteSerializer.java
@@ -21,10 +21,10 @@
 import java.nio.charset.Charset;
 import java.util.Arrays;
 
-import org.jboss.netty.buffer.ChannelBuffer;
+import io.netty.buffer.ByteBuf;
 
 public class StringByteSerializer {
-    public static String readFrom(final ChannelBuffer data, final int length) {
+    public static String readFrom(final ByteBuf data, final int length) {
         byte[] stringBytes = new byte[length];
         data.readBytes(stringBytes);
         // find the first index of 0
@@ -37,7 +37,7 @@
         return new String(Arrays.copyOf(stringBytes, index), Charset.forName("ascii"));
     }
 
-    public static void writeTo(final ChannelBuffer data, final int length,
+    public static void writeTo(final ByteBuf data, final int length,
             final String value) {
         try {
             byte[] name = value.getBytes("ASCII");
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPAddressTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPAddressTest.java
index 6e9d047..420f176 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPAddressTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPAddressTest.java
@@ -1,5 +1,7 @@
 package org.projectfloodlight.openflow.types;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -8,9 +10,12 @@
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
+import java.util.List;
 
 import org.junit.Test;
 
+import com.google.common.collect.ImmutableList;
+
 /**
  * Most tests are in IPv4AddressTest and IPv6AddressTest
  * Just exception testing here
@@ -92,6 +97,16 @@
     }
 
     @Test
+    public void testToInetAddress() throws Exception {
+        IPAddress<?> ip0 = IPAddress.of("201.202.3.4");
+        IPAddress<?> ip1 = IPAddress.of("2001:db8:abcd::1:2:3:4");
+        InetAddress ia0 = ip0.toInetAddress();
+        InetAddress ia1 = ip1.toInetAddress();
+        assertEquals(ia0, InetAddress.getByName("201.202.3.4"));
+        assertEquals(ia1, InetAddress.getByName("2001:db8:abcd:0:1:2:3:4"));
+    }
+
+    @Test
     public void testContains() {
 
         // Test IPv4 Mask
@@ -131,6 +146,93 @@
     }
 
     @Test
+    public void testIsUnspecified() {
+        IPAddress<?> unspecifiedV4 = IPAddress.of("0.0.0.0");
+        IPAddress<?> unspecifiedV6 = IPAddress.of("::");
+        assertThat(unspecifiedV4.isUnspecified(), is(true));
+        assertThat(unspecifiedV6.isUnspecified(), is(true));
+        List<String> others = ImmutableList.of(
+                "0.0.0.1",
+                "1.2.3.4",
+                "10.0.0.0",
+                "127.0.0.1",
+                "255.255.255.255",
+                "::1",
+                "2001:db8:1:2::5:6",
+                "fc00::4:5:6:7",
+                "fe80::1234",
+                "ff02::1");
+        for (String other : others) {
+            assertThat(IPAddress.of(other).isUnspecified(), is(false));
+        }
+    }
+
+    @Test
+    public void testIsLoopback() {
+        List<String> loopbacks = ImmutableList.of(
+                "127.0.0.0",
+                "127.0.0.1",
+                "127.0.0.2",
+                "127.0.0.255",
+                "127.1.2.3",
+                "127.101.102.103",
+                "127.201.202.203",
+                "127.255.255.255",
+                "::1");
+        for (String loopback : loopbacks) {
+            assertThat(IPAddress.of(loopback).isLoopback(), is(true));
+        }
+        List<String> others = ImmutableList.of(
+                "0.0.0.0",
+                "0.0.0.1",
+                "10.0.0.1",
+                "126.255.255.255",
+                "128.0.0.0",
+                "255.255.255.255",
+                "::",
+                "::2",
+                "2001:db8::1:2:3:4",
+                "fe80:7:6:5:4:3:2:1",
+                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
+        for (String other : others) {
+            assertThat(IPAddress.of(other).isLoopback(), is(false));
+        }
+    }
+
+    @Test
+    public void testIsLinkLocal() {
+        List<String> linkLocals = ImmutableList.of(
+                "169.254.0.0",
+                "169.254.0.1",
+                "169.254.1.2",
+                "169.254.101.102",
+                "169.254.201.202",
+                "169.254.255.255",
+                "fe80::",
+                "fe80::1",
+                "fe80::1:2:3:4:5:6:7",
+                "fe80:aaaa:bbbb:cccc:dddd:eeee:ffff:1234",
+                "febf::",
+                "febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
+        for (String linkLocal : linkLocals) {
+            assertThat(IPAddress.of(linkLocal).isLinkLocal(), is(true));
+        }
+        List<String> others = ImmutableList.of(
+                "0.0.0.0",
+                "1.2.3.4",
+                "169.253.255.255",
+                "169.255.0.0",
+                "255.255.255.255",
+                "::",
+                "fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
+                "fec0::",
+                "ff02::1");
+        for (String other : others) {
+            assertThat(IPAddress.of(other).isLinkLocal(), is(false));
+        }
+    }
+
+    @Test
     public void testMulticastIp() {
         IPAddress<?> ip0 = IPAddress.of("240.2.3.4");
         IPAddress<?> ip1 = IPAddress.of("224.0.1.1");
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv4AddressTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv4AddressTest.java
index 5d95a5a..d0beb12 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv4AddressTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv4AddressTest.java
@@ -8,13 +8,16 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import io.netty.buffer.Unpooled;
 
 import java.net.Inet4Address;
 import java.net.InetAddress;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
 
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matchers;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Test;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
@@ -228,6 +231,84 @@
     }
 
     @Test
+    public void testOf4Integers() {
+        Map<IPv4Address, IPv4Address> map = new HashMap<>();
+        map.put(IPv4Address.of(0, 0, 0, 0), IPv4Address.of(0));
+        map.put(IPv4Address.of(1, 2, 3, 4), IPv4Address.of("1.2.3.4"));
+        map.put(IPv4Address.of(6, 7, 8, 9), IPv4Address.of("6.7.8.9"));
+        map.put(IPv4Address.of(10, 1, 2, 3), IPv4Address.of("10.1.2.3"));
+        map.put(IPv4Address.of(10, 201, 202, 203), IPv4Address.of("10.201.202.203"));
+        map.put(IPv4Address.of(192, 168, 0, 101), IPv4Address.of("192.168.0.101"));
+        map.put(IPv4Address.of(211, 212, 213, 214), IPv4Address.of("211.212.213.214"));
+        map.put(IPv4Address.of(255, 255, 255, 255), IPv4Address.of(0xFF_FF_FF_FF));
+        for (Entry<IPv4Address, IPv4Address> entry : map.entrySet()) {
+            assertThat(entry.getKey(), equalTo(entry.getValue()));
+        }
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative1() {
+        IPv4Address.of(-3, 4, 5, 6);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative2() {
+        IPv4Address.of(3, -4, 5, 6);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative3() {
+        IPv4Address.of(3, 4, -5, 6);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative4() {
+        IPv4Address.of(3, 4, 5, -6);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative5() {
+        // ((byte) 128) is actually -128
+        IPv4Address.of(101, 102, 103, (byte) 128);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative6() {
+        // ((byte) 255) is actually -1
+        IPv4Address.of(101, 102, 103, (byte) 255);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionNegative7() {
+        IPv4Address.of(-1, -1, -1, -1);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig1() {
+        IPv4Address.of(1000, 2, 3, 4);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig2() {
+        IPv4Address.of(1, 20000, 3, 4);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig3() {
+        IPv4Address.of(1, 2, 300000, 4);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig4() {
+        IPv4Address.of(1, 2, 3, 4000000);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testOf4IntegersExceptionTooBig5() {
+        IPv4Address.of(256, 256, 256, 256);
+    }
+
+    @Test
     public void testOfCidrMaskLength() {
         for (int i = 0; i <= 32; i++) {
             assertEquals(IPv4Address.ofCidrMaskLength(i).asCidrMaskLength(), i);
@@ -307,7 +388,7 @@
     @Test
     public void testReadFrom() throws OFParseError {
         for(int i=0; i < testAddresses.length; i++ ) {
-            IPv4Address ip = IPv4Address.read4Bytes(ChannelBuffers.copiedBuffer(testAddresses[i]));
+            IPv4Address ip = IPv4Address.read4Bytes(Unpooled.copiedBuffer(testAddresses[i]));
             assertEquals(testInts[i], ip.getInt());
             assertArrayEquals(testAddresses[i], ip.getBytes());
             assertEquals(testStrings[i], ip.toString());
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv6AddressTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv6AddressTest.java
index a94f443..d778c1b 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv6AddressTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/IPv6AddressTest.java
@@ -1,6 +1,14 @@
 package org.projectfloodlight.openflow.types;
 
-import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import io.netty.buffer.Unpooled;
 
 import java.net.Inet6Address;
 import java.net.InetAddress;
@@ -8,7 +16,6 @@
 
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matchers;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Test;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
@@ -277,7 +284,7 @@
     public void testReadFrom() throws OFParseError, UnknownHostException {
         for(int i=0; i < testStrings.length; i++ ) {
             byte[] bytes = Inet6Address.getByName(testStrings[i]).getAddress();
-            IPv6Address ip = IPv6Address.read16Bytes(ChannelBuffers.copiedBuffer(bytes));
+            IPv6Address ip = IPv6Address.read16Bytes(Unpooled.copiedBuffer(bytes));
             assertEquals(testStrings[i], ip.toString());
             assertArrayEquals(bytes, ip.getBytes());
         }
@@ -314,6 +321,13 @@
         assertEquals("0000:0000:0000:0000:0000:0000:0000:0000", IPv6Address.of("::").toString(false, true));
         assertEquals("1::4:5:6:0:8", IPv6Address.of("1:0:0:4:5:6:0:8").toString(true, false));
         assertEquals("1:0:0:4::8", IPv6Address.of("1:0:0:4:0:0:0:8").toString(true, false));
+        // Two equal length zero runs; should zero compress the first instance
+        assertEquals("1::4:2:0:0:8", IPv6Address.of("1:0:0:4:2:0:0:8").toString(true, false));
+        // Shouldn't zero compress a single zero
+        assertEquals("1:0:2:4:3:1:0:8", IPv6Address.of("1:0:2:4:3:1:0:8").toString(true, false));
+        // Test zero runs at the end of the address since that's a different code path in toString
+        assertEquals("1::4:2:8:0:0", IPv6Address.of("1:0:0:4:2:8:0:0").toString(true, false));
+        assertEquals("1:3:2:4:3:1:5:0", IPv6Address.of("1:3:2:4:3:1:5:0").toString(true, false));
     }
 
     @Test
@@ -427,4 +441,76 @@
         assertEquals("::", IPv6Address.of("::%eth0").toString(true, false));
         assertEquals("1:0:0:4::8", IPv6Address.of("1:0:0:4:0:0:0:8%2").toString(true, false));
     }
+
+    private void testModifiedEui64(
+            String network, String macAddress, String expectedIpAddress) {
+
+        IPv6AddressWithMask networkObj = IPv6AddressWithMask.of(network);
+        MacAddress macAddressObj = MacAddress.of(macAddress);
+        MacAddress macAddressAdd1 = MacAddress.of(
+                macAddressObj.getLong() + 1 & 0xFFFF_FFFF_FFFFL);
+        MacAddress macAddressSub1 = MacAddress.of(
+                macAddressObj.getLong() - 1 & 0xFFFF_FFFF_FFFFL);
+        IPv6Address ipAddressObj = IPv6Address.of(networkObj, macAddressObj);
+        IPv6Address expectedObj = IPv6Address.of(expectedIpAddress);
+
+        assertThat(ipAddressObj, is(expectedObj));
+        assertThat(ipAddressObj.isModifiedEui64Derived(macAddressObj), is(true));
+        assertThat(ipAddressObj.isModifiedEui64Derived(macAddressAdd1), is(false));
+        assertThat(ipAddressObj.isModifiedEui64Derived(macAddressSub1), is(false));
+    }
+
+    @Test
+    public void testModifiedEui64() throws Exception {
+        testModifiedEui64(
+                "fe80::/64", "00:00:00:00:00:00", "fe80::0200:ff:fe00:0");
+        testModifiedEui64(
+                "fe80::/64", "12:34:56:78:9a:bc", "fe80::1034:56ff:fe78:9abc");
+        testModifiedEui64(
+                "fe80::/64", "ff:ff:ff:ff:ff:ff", "fe80::fdff:ffff:feff:ffff");
+        testModifiedEui64(
+                "fe80::/10", "5c:16:c7:12:34:56", "fe80::5e16:c7ff:fe12:3456");
+        testModifiedEui64(
+                "2001:db8:9876:5400::/56", "00:0c:29:ab:cd:ef",
+                "2001:db8:9876:5400:20c:29ff:feab:cdef");
+        testModifiedEui64(
+                "fd00:9999:8888::/48", "52:54:00:78:56:34",
+                "fd00:9999:8888::5054:00ff:fe78:5634");
+        testModifiedEui64(
+                "2001:db8:7777:aabb::/64", "14:10:9f:00:00:cd",
+                "2001:db8:7777:aabb:1610:9fff:fe00:00cd");
+    }
+
+    @Test(expected=NullPointerException.class)
+    public void testModifiedEui64ExceptionNullNetwork() {
+        IPv6Address.of(
+                (IPv6AddressWithMask) null,
+                MacAddress.of("00:50:56:12:34:56"));
+    }
+
+    @Test(expected=NullPointerException.class)
+    public void testModifiedEui64ExceptionNullMacAddress() {
+        IPv6Address.of(
+                IPv6AddressWithMask.LINK_LOCAL_NETWORK,
+                (MacAddress) null);
+    }
+
+    @Test(expected=NullPointerException.class)
+    public void testModifiedEui64ExceptionNullDerivedMacAddress() {
+        IPv6Address.NONE.isModifiedEui64Derived(null);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testModifiedEui64ExceptionPrefixLengthNo() {
+        IPv6Address.of(
+                IPv6Address.of("fef::").withMask(IPv6Address.of("f0f0:1234::")),
+                MacAddress.of("5c:16:c7:00:00:00"));
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testModifiedEui64ExceptionPrefixLengthTooLong() {
+        IPv6Address.of(
+                IPv6AddressWithMask.of("fe80::/65"),
+                MacAddress.of("5c:16:c7:00:00:00"));
+    }
 }
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/MacAddressTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/MacAddressTest.java
index e1c7721..f201b47 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/MacAddressTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/MacAddressTest.java
@@ -1,8 +1,9 @@
 package org.projectfloodlight.openflow.types;
 
+import io.netty.buffer.Unpooled;
+
 import java.util.Arrays;
 
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Test;
 import org.projectfloodlight.openflow.exceptions.OFParseError;
 
@@ -22,12 +23,18 @@
             {(byte) 255, (byte) 255, (byte) 255, (byte) 255, (byte) 255, (byte) 255 }
     };
 
-    String[] testStrings = {
+    String[] testColonStrings = {
             "01:02:03:04:05:06",
             "80:00:00:00:00:01",
-            "ff:ff:ff:ff:ff:ff"
+            "ff:ff:ff:ff:ff:ff",
     };
 
+    String[] testHyphenStrings = {
+             "01-02-03-04-05-06",
+             "80-00-00-00-00-01",
+             "ff-ff-ff-ff-ff-ff",
+     };
+
     long[] testInts = {
             0x00010203040506L,
             0x00800000000001L,
@@ -43,7 +50,8 @@
             "00:fff:ef:12:12:ff",
             "01:02:03:04:05;06",
             "0:1:2:3:4:5:6",
-            "01:02:03:04"
+            "01:02:03:04",
+            "01-02-03:04-05-06",
     };
 
     byte[][] invalidMacBytes = {
@@ -53,11 +61,15 @@
 
     @Test
     public void testOfString() {
+        testOfStringForArray(testColonStrings);
+        testOfStringForArray(testHyphenStrings);
+    }
+
+    private void testOfStringForArray(String [] strings) {
         for(int i=0; i < testAddresses.length; i++ ) {
-            MacAddress ip = MacAddress.of(testStrings[i]);
+            MacAddress ip = MacAddress.of(strings[i]);
             assertEquals(testInts[i], ip.getLong());
             assertArrayEquals(testAddresses[i], ip.getBytes());
-            assertEquals(testStrings[i], ip.toString());
         }
     }
 
@@ -67,17 +79,17 @@
             MacAddress ip = MacAddress.of(testAddresses[i]);
             assertEquals("error checking long representation of "+Arrays.toString(testAddresses[i]) + "(should be "+Long.toHexString(testInts[i]) +")", testInts[i],  ip.getLong());
             assertArrayEquals(testAddresses[i], ip.getBytes());
-            assertEquals(testStrings[i], ip.toString());
+            assertEquals(testColonStrings[i], ip.toString());
         }
     }
 
     @Test
     public void testReadFrom() throws OFParseError {
         for(int i=0; i < testAddresses.length; i++ ) {
-            MacAddress ip = MacAddress.read6Bytes(ChannelBuffers.copiedBuffer(testAddresses[i]));
+            MacAddress ip = MacAddress.read6Bytes(Unpooled.copiedBuffer(testAddresses[i]));
             assertEquals(testInts[i], ip.getLong());
             assertArrayEquals(testAddresses[i], ip.getBytes());
-            assertEquals(testStrings[i], ip.toString());
+            assertEquals(testColonStrings[i], ip.toString());
         }
     }
 
@@ -156,14 +168,72 @@
     }
 
     @Test
+
+    public void testForIPv4MulticastAddress() {
+        IPv4Address ip = IPv4Address.of("224.1.1.1");
+        MacAddress mac = MacAddress.forIPv4MulticastAddress(ip);
+        MacAddress expectedMac = MacAddress.of("01:00:5E:01:01:01");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("224.129.1.1");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:01:01");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("225.1.1.1");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:01:01");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("239.129.1.1");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:01:01");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("224.1.2.3");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:02:03");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv4Address.of("239.129.2.3");
+        mac = MacAddress.forIPv4MulticastAddress(ip);
+        expectedMac = MacAddress.of("01:00:5E:01:02:03");
+        assertTrue(mac.equals(expectedMac));
+    }
+
     public void testOfDatapathid() {
         MacAddress mac = MacAddress.of(DatapathId.NONE);
         assertThat(mac, is(MacAddress.NONE));
 
-        for (String s : testStrings) {
+        for (String s : testColonStrings) {
             DatapathId dpid = DatapathId.of("00:00:" + s);
             mac = MacAddress.of(dpid);
             assertThat(mac, is(MacAddress.of(s)));
         }
     }
+
+    @Test
+    public void forIPv6MulticastAddr() {
+        IPv6Address ip = IPv6Address.of("ff02::1:ff00:0");
+        MacAddress mac = MacAddress.forIPv6MulticastAddr(ip);
+        MacAddress expectedMac = MacAddress.of("33:33:ff:00:00:00");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv6Address.of("ff02::1:ff01:0203");
+        mac = MacAddress.forIPv6MulticastAddr(ip);
+        expectedMac = MacAddress.of("33:33:ff:01:02:03");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv6Address.of("ff02::1:0102:0304");
+        mac = MacAddress.forIPv6MulticastAddr(ip);
+        expectedMac = MacAddress.of("33:33:01:02:03:04");
+        assertTrue(mac.equals(expectedMac));
+
+        ip = IPv6Address.of("2001::1:0102:0304");
+        try {
+            mac = MacAddress.forIPv6MulticastAddr(ip);
+        } catch(IllegalArgumentException e) {
+                // ok
+        }
+    }
 }
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/OFErrorCauseDataTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/OFErrorCauseDataTest.java
index 9a5a4dc..6d6c545 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/OFErrorCauseDataTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/OFErrorCauseDataTest.java
@@ -2,10 +2,10 @@
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 
 import org.hamcrest.Matchers;
-import org.jboss.netty.buffer.ChannelBuffer;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Test;
 import org.projectfloodlight.openflow.protocol.OFFactories;
 import org.projectfloodlight.openflow.protocol.OFFlowAdd;
@@ -60,7 +60,7 @@
         .setPriority(6000)
         .build();
 
-        ChannelBuffer bb = ChannelBuffers.dynamicBuffer();
+        ByteBuf bb = Unpooled.buffer();
         flowAdd.writeTo(bb);
         byte[] flowAddBytes = new byte[bb.readableBytes()];
         bb.readBytes(flowAddBytes);
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/U128Test.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/U128Test.java
index 81d9d7f..56dc070 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/U128Test.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/U128Test.java
@@ -8,12 +8,12 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 
 import java.text.MessageFormat;
 
 import org.hamcrest.Matchers;
-import org.jboss.netty.buffer.ChannelBuffer;
-import org.jboss.netty.buffer.ChannelBuffers;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -36,12 +36,12 @@
 
     @Test
     public void testReadBytes() {
-        ChannelBuffer empty = ChannelBuffers.wrappedBuffer(new byte[16]);
+        ByteBuf empty = Unpooled.wrappedBuffer(new byte[16]);
         U128 uEmpty = U128.read16Bytes(empty);
         assertThat(uEmpty.getMsb(), equalTo(0L));
         assertThat(uEmpty.getLsb(), equalTo(0L));
 
-        ChannelBuffer value = ChannelBuffers.wrappedBuffer(
+        ByteBuf value = Unpooled.wrappedBuffer(
                 new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88,
                         (byte) 0x99, (byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd,
                         (byte) 0xee, (byte) 0xff, 0x11 });
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/VxlanNITest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/VxlanNITest.java
new file mode 100644
index 0000000..818dd07
--- /dev/null
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/types/VxlanNITest.java
@@ -0,0 +1,50 @@
+package org.projectfloodlight.openflow.types;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import org.junit.Test;
+
+
+public class VxlanNITest {
+
+    @Test
+    public void testValidMaxVni() {
+        VxlanNI.ofVni(0x00ffffff);
+    }
+
+    @Test
+    public void testValidMinVni() {
+        VxlanNI.ofVni(0x0000001);
+    }
+
+    @Test
+    public void testVniEquals() {
+        assertEquals((int)VxlanNI.ofVni(0x01).getVni(), 0x01);
+        assertEquals((int)VxlanNI.ofVni(0x00ffFFff).getVni(), 0x00ffFFff);
+    }
+
+    @Test
+    public void testVniObjects() {
+        VxlanNI o = VxlanNI.ofVni(0x00ffFFff);
+        VxlanNI m = VxlanNI.ofVni(0x00ffFFff);
+        assertEquals(o.compareTo(m), 0);
+        assertEquals(o.getVni(), m.getVni());
+        assertFalse(!o.equals(m));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidVni1() {
+        VxlanNI.ofVni(0xFFffFFff);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidVni2() {
+        VxlanNI.ofVni(0x0FffFFff);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidVni3() {
+        VxlanNI.ofVni(0x01FffFFff);
+    }
+}
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/util/HexStringTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/util/HexStringTest.java
index 360cb5a..ca5df98 100644
--- a/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/util/HexStringTest.java
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/openflow/util/HexStringTest.java
@@ -17,14 +17,21 @@
 
 package org.projectfloodlight.openflow.util;
 
+import static org.hamcrest.Matchers.equalTo;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import java.util.Random;
 
 import org.junit.Test;
 
+import com.google.common.collect.ImmutableList;
+
 /**
  * Does hexstring conversion work?
  *
  * @author Rob Sherwood (rob.sherwood@stanford.edu)
+ * @author Andreas Wundsam <andreas.wundsam@bigswitch.com>
  */
 public class HexStringTest {
 
@@ -41,7 +48,7 @@
         String dpidStr = "3e:1f:01:fc:72:8c:63:31";
         long valid = 0x3e1f01fc728c6331L;
         long testLong = HexString.toLong(dpidStr);
-        assertEquals(valid, testLong);
+        assertEquals("was: " + Long.toHexString(testLong), valid, testLong);
     }
 
     @Test
@@ -49,7 +56,7 @@
         String dpidStr = "1f:1:fc:72:3:f:31";
         long valid = 0x1f01fc72030f31L;
         long testLong = HexString.toLong(dpidStr);
-        assertEquals(valid, testLong);
+        assertEquals("was: " + Long.toHexString(testLong), valid, testLong);
     }
 
     @Test
@@ -76,13 +83,17 @@
     }
 
     @Test(expected=NumberFormatException.class)
+    public void testToLongErrorColonAtEnd() {
+        HexString.toLong("03:01:");
+    }
+
+    @Test(expected=NumberFormatException.class)
     public void testToLongErrorInvalidHexDigit() {
         HexString.toLong("ss:01");
     }
 
-    @Test(expected=NumberFormatException.class)
     public void testToLongErrorEmptyString() {
-        HexString.toLong("");
+        assertThat(HexString.toLong(""), equalTo(0L));
     }
 
 
@@ -94,10 +105,138 @@
         assertEquals(valid, testString);
     }
 
-    @Test(expected=NumberFormatException.class)
-    public void testFromHexStringError() {
-        String invalidStr = "00:00:00:00:00:00:ffff";
-        HexString.fromHexString(invalidStr);
+    @Test
+    public void testToStringBytes2() {
+        byte[] dpid = { 1, 2, 3, 4 };
+        String valid = "01:02:03:04";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
     }
+
+    @Test
+    public void testToStringBytes3() {
+        byte[] dpid = { (byte) 0xff };
+        String valid = "ff";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
+    }
+
+    @Test
+    public void testToStringEmpty() {
+        byte[] dpid = { };
+        String valid = "";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
+    }
+
+    @Test
+    public void testToStringLong() {
+        byte[] dpid = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+        String valid = "01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
+    }
+
+    @Test
+    public void testToZero() {
+        byte[] dpid = { 0, 0, 0, 0};
+        String valid = "00:00:00:00";
+        String testString = HexString.toHexString(dpid);
+        assertEquals(valid, testString);
+    }
+
+    @Test
+    public void testToStringFromLong() {
+        assertThat(HexString.toHexString(0x0L), equalTo("00:00:00:00:00:00:00:00"));
+        assertThat(HexString.toHexString(0x00_00_00_00_00_00_00_01L), equalTo("00:00:00:00:00:00:00:01"));
+        assertThat(HexString.toHexString(0x01_02_03_04_05_06_07_08L), equalTo("01:02:03:04:05:06:07:08"));
+        assertThat(HexString.toHexString(0x00_00_ff_fe_fd_fc_fb_fa_f9_f8L), equalTo("ff:fe:fd:fc:fb:fa:f9:f8"));
+        assertThat(HexString.toHexString(0x80_70_60_50_40_30_20_10L), equalTo("80:70:60:50:40:30:20:10"));
+    }
+
+    @Test
+    public void testToStringFromLongPad6() {
+        assertThat(HexString.toHexString(0x0L, 6), equalTo("00:00:00:00:00:00"));
+        assertThat(HexString.toHexString(0x00_00_00_00_00_00_00_01L, 6), equalTo("00:00:00:00:00:01"));
+        assertThat(HexString.toHexString(0x00_00_01_02_03_04_05_06L, 6), equalTo("01:02:03:04:05:06"));
+        assertThat(HexString.toHexString(0x00_00_ff_fe_fd_fc_fb_faL, 6), equalTo("ff:fe:fd:fc:fb:fa"));
+        // when supplying a value longer than 6, it is displayed completely
+        assertThat(HexString.toHexString(0x80_70_60_50_40_30_20_10L, 6), equalTo("80:70:60:50:40:30:20:10"));
+    }
+
+    @Test
+    public void testToBytes() {
+        assertThat(HexString.toBytes(""), equalTo(new byte[]{}));
+        assertThat(HexString.toBytes("1"), equalTo(new byte[]{0x01}));
+        assertThat(HexString.toBytes("f"), equalTo(new byte[]{0x0f}));
+        assertThat(HexString.toBytes("10"), equalTo(new byte[]{(byte) 0x10}));
+        assertThat(HexString.toBytes("80"), equalTo(new byte[]{(byte) 0x80}));
+        assertThat(HexString.toBytes("ff"), equalTo(new byte[]{(byte) 0xff}));
+        assertThat(HexString.toBytes("0:0"), equalTo(new byte[]{(byte) 0x00, 0x00}));
+        assertThat(HexString.toBytes("00:00"), equalTo(new byte[]{(byte) 0x00, 0x00}));
+        assertThat(HexString.toBytes("0:1"), equalTo(new byte[]{(byte) 0x00, 0x01}));
+        assertThat(HexString.toBytes("00:1"), equalTo(new byte[]{(byte) 0x00, 0x01}));
+        assertThat(HexString.toBytes("0:01"), equalTo(new byte[]{(byte) 0x00, 0x01}));
+        assertThat(HexString.toBytes("1:0"), equalTo(new byte[]{(byte) 0x01, 0x00}));
+        assertThat(HexString.toBytes("01:00"), equalTo(new byte[]{(byte) 0x01, 0x00}));
+        assertThat(HexString.toBytes("01:02:03:04"), equalTo(new byte[]{(byte) 0x01, 0x02, 03, 04}));
+        assertThat(HexString.toBytes("ff:fe:03:04"), equalTo(new byte[]{(byte) 0xff, (byte) 0xfe, 03, 04}));
+        assertThat(HexString.toBytes("ff:fe:3:4"), equalTo(new byte[]{(byte) 0xff, (byte) 0xfe, 03, 04}));
+        assertThat(HexString.toBytes("01:02:03:04:05:06"), equalTo(new byte[]{0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }));
+        assertThat(HexString.toBytes("ff:1:fe:2:fd"),
+                equalTo(new byte[]{(byte) 0xff, 0x01, (byte) 0xfe, 0x02, (byte) 0xfd}));
+
+    }
+    @Test
+    public void testToBytesRandom() {
+        Random r = new Random();
+        for(int length: ImmutableList.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 15, 16, 32, 63, 64, 128, 255, 256, 511, 512, 1023, 1024)) {
+            StringBuilder build = new StringBuilder();
+            byte[] bytes = new byte[length];
+            for(int i=0; i<length; i++) {
+                byte b = (byte) r.nextInt(256);
+                build.append(String.format("%02x", b));
+                if(i < length-1) {
+                    build.append(":");
+                }
+                bytes[i] = b;
+            }
+            assertThat("For length "+ length + ", ",
+                    HexString.toBytes(build.toString()),
+                    equalTo(bytes));
+        }
+    }
+
+    @Test(expected=NumberFormatException.class)
+    public void testToBytesError() {
+        String invalidStr = "00:00:00:00:00:00:ffff";
+        HexString.toBytes(invalidStr);
+    }
+
+
+    @Test(expected=NumberFormatException.class)
+    public void testToBytesError2() {
+        String invalidStr = ":01:02:03";
+        HexString.toBytes(invalidStr);
+    }
+
+    @Test(expected=NumberFormatException.class)
+    public void testToBytesError3() {
+        String invalidStr = "01::02:03";
+        HexString.toBytes(invalidStr);
+    }
+
+    @Test(expected=NumberFormatException.class)
+    public void testBoBytesError4() {
+        String invalidStr = "01:02:03:";
+        HexString.toBytes(invalidStr);
+    }
+
+    @Test(expected=NumberFormatException.class)
+    public void testtoBytesError5() {
+        String invalidStr = "01:0X";
+        HexString.toBytes(invalidStr);
+    }
+
 }
 
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/OFBundleAddTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/OFBundleAddTest.java
new file mode 100644
index 0000000..48a80c4
--- /dev/null
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/OFBundleAddTest.java
@@ -0,0 +1,74 @@
+package org.projectfloodlight.protocol;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.projectfloodlight.openflow.protocol.OFBundleAddMsg;
+import org.projectfloodlight.openflow.protocol.OFFactories;
+import org.projectfloodlight.openflow.protocol.OFFactory;
+import org.projectfloodlight.openflow.protocol.OFFlowAdd;
+import org.projectfloodlight.openflow.protocol.OFVersion;
+import org.projectfloodlight.openflow.types.BundleId;
+
+/** Custom tests that validate that BundleAdd messages inherit the XID from their
+ *  contained message, as per OF Spec 1.4.0:
+ *  <p>
+ *  7.3.9.6 Adding messages to a bundle
+ *  <p>
+ *     Message added in a bundle should have a unique xid to help matching errors to messages,
+ *     and the xid of the bundle add message must be the same.
+ *  </p>
+ *
+ * @author Andreas Wundsam <andreas.wundsam@bigswitch.com>
+ */
+public class OFBundleAddTest {
+    private final OFFactory factory = OFFactories.getFactory(OFVersion.OF_14);
+    private OFFlowAdd flowAdd;
+
+    @Before
+    public void setup() {
+        flowAdd = factory.buildFlowAdd().build();
+
+    }
+
+    @Test
+    public void testBundleAddBuilder() {
+        OFBundleAddMsg bundleAdd = createBundleAdd();
+        assertThat(bundleAdd.getXid(), equalTo(flowAdd.getXid()));
+    }
+
+    private OFBundleAddMsg createBundleAdd() {
+        return factory.buildBundleAddMsg()
+                .setBundleId(BundleId.of(1))
+                .setData(flowAdd)
+                .build();
+    }
+
+    @Test
+    public void testBundleAddBuilderWithParent() {
+        OFBundleAddMsg bundleAdd = createBundleAdd();
+
+        // validate BuilderWithParent
+        OFBundleAddMsg builtFromOtherMessage = bundleAdd.createBuilder()
+           .build();
+
+        assertThat(builtFromOtherMessage.getXid(), equalTo(builtFromOtherMessage.getData().getXid()));
+    }
+
+    @Test
+    public void testBundleAddBuilderWithParentOverwrite() {
+        OFFlowAdd flowAdd2 = factory.buildFlowAdd().setXid(1234L).build();
+
+        // BuilderWithParent, overwrite with new message
+        OFBundleAddMsg bundleAdd = createBundleAdd();
+
+        OFBundleAddMsg builtFromOtherMessage = bundleAdd.createBuilder()
+           .setData(flowAdd2)
+           .build();
+
+        assertThat(builtFromOtherMessage.getXid(), equalTo(flowAdd2.getXid()));
+    }
+
+}
diff --git a/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/match/OFMatchPrerequisitesTest.java b/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/match/OFMatchPrerequisitesTest.java
new file mode 100644
index 0000000..89cd536
--- /dev/null
+++ b/java_gen/pre-written/src/test/java/org/projectfloodlight/protocol/match/OFMatchPrerequisitesTest.java
@@ -0,0 +1,86 @@
+package org.projectfloodlight.protocol.match;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertThat;
+import static org.projectfloodlight.openflow.protocol.match.MatchField.ETH_TYPE;
+import static org.projectfloodlight.openflow.protocol.match.MatchField.IPV4_SRC;
+
+import java.util.Arrays;
+
+import org.hamcrest.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.projectfloodlight.openflow.protocol.OFFactories;
+import org.projectfloodlight.openflow.protocol.OFFactory;
+import org.projectfloodlight.openflow.protocol.OFVersion;
+import org.projectfloodlight.openflow.protocol.match.Match;
+import org.projectfloodlight.openflow.protocol.match.MatchField;
+import org.projectfloodlight.openflow.types.EthType;
+import org.projectfloodlight.openflow.types.IPv4Address;
+
+@RunWith(Parameterized.class)
+public class OFMatchPrerequisitesTest {
+    private final OFFactory factory;
+
+    @Parameters(name="{index}.ChannelHandlerVersion={0}")
+    public static Iterable<Object[]> data() {
+        return Arrays.asList(new Object[][] {
+                {OFVersion.OF_10},
+                {OFVersion.OF_13},
+                {OFVersion.OF_14}
+        });
+    }
+
+    public OFMatchPrerequisitesTest(OFVersion version) {
+        factory = OFFactories.getFactory(version);
+    }
+
+    @Test
+    public void testPreRequisitesNotMet() {
+        Match match = factory.buildMatch()
+           .setExact(ETH_TYPE, EthType.IPv6)
+           .setExact(IPV4_SRC, IPv4Address.of("1.2.3.4"))
+           .build();
+
+        assertThat(match.get(ETH_TYPE), equalTo(EthType.IPv6));
+        assertThat(match.isExact(ETH_TYPE), equalTo(true));
+        assertThat(match.isPartiallyMasked(ETH_TYPE), equalTo(false));
+        assertThat(match.isFullyWildcarded(ETH_TYPE), equalTo(false));
+
+        assertThat(match.get(IPV4_SRC), nullValue());
+        assertThat(match.isExact(IPV4_SRC), equalTo(false));
+        assertThat(match.isPartiallyMasked(IPV4_SRC), equalTo(false));
+        assertThat(match.isFullyWildcarded(IPV4_SRC), equalTo(true));
+
+        Iterable<MatchField<?>> matchFields = match.getMatchFields();
+        assertThat(matchFields, Matchers.<MatchField<?>>iterableWithSize(1));
+        assertThat(matchFields, Matchers.<MatchField<?>>contains(MatchField.ETH_TYPE));
+    }
+
+    @Test
+    public void testPreRequisitesMet() {
+        Match match = factory.buildMatch()
+           .setExact(ETH_TYPE, EthType.IPv4)
+           .setExact(IPV4_SRC, IPv4Address.of("1.2.3.4"))
+           .build();
+
+        assertThat(match.get(ETH_TYPE), equalTo(EthType.IPv4));
+        assertThat(match.isExact(ETH_TYPE), equalTo(true));
+        assertThat(match.isPartiallyMasked(ETH_TYPE), equalTo(false));
+        assertThat(match.isFullyWildcarded(ETH_TYPE), equalTo(false));
+
+        assertThat(match.get(IPV4_SRC), equalTo(IPv4Address.of("1.2.3.4")));
+        assertThat(match.isExact(IPV4_SRC), equalTo(true));
+        assertThat(match.isPartiallyMasked(IPV4_SRC), equalTo(false));
+        assertThat(match.isFullyWildcarded(IPV4_SRC), equalTo(false));
+
+        Iterable<MatchField<?>> matchFields = match.getMatchFields();
+        assertThat(matchFields, Matchers.<MatchField<?>>iterableWithSize(2));
+        assertThat(matchFields, Matchers.<MatchField<?>>contains(MatchField.ETH_TYPE, MatchField.IPV4_SRC));
+    }
+
+
+}