* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.api.openflow.protocol.serialization;
-import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
+import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
-public interface MatchEntrySerializer extends OFSerializer<Match> {
+public interface MatchEntrySerializer {
/**
- * Checks if current match is this match type.
+ * Serialize this match entry if it is present in the match.
+ *
* @param match Openflow match
- * @return true if matched
+ * @param outBuffer output buffer
*/
- boolean matchTypeCheck(Match match);
-
+ void serializeIfPresent(Match match, ByteBuf outBuffer);
}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
import io.netty.buffer.ByteBuf;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-public abstract class AbstractExperimenterMatchEntrySerializer extends AbstractMatchEntrySerializer {
+public abstract class AbstractExperimenterMatchEntrySerializer<E, M> extends AbstractMatchEntrySerializer<E, M> {
+ private final int experimenterId;
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeInt(Long.valueOf(getExperimenterId()).intValue());
+ protected AbstractExperimenterMatchEntrySerializer(final HeaderWriter<E, M> headerWriter,
+ final long experimenterId) {
+ super(headerWriter);
+ this.experimenterId = Long.valueOf(experimenterId).intValue();
}
- @Override
- public void serializeHeader(Match match, ByteBuf outBuffer) {
- outBuffer.writeShort(getOxmClassCode());
-
- int fieldAndMask = getOxmFieldCode() << 1;
- int length = getValueLength();
-
- if (getHasMask(match)) {
- fieldAndMask |= 1;
- length *= 2;
- }
-
- outBuffer.writeByte(fieldAndMask);
+ protected AbstractExperimenterMatchEntrySerializer(final int oxmFieldCode, final int valueLength,
+ final long experimenterId) {
+ this(new ConstantHeaderWriter<>(OxmMatchConstants.EXPERIMENTER_CLASS, oxmFieldCode, valueLength,
+ EncodeConstants.SIZE_OF_INT_IN_BYTES), experimenterId);
+ }
- // Add length of experimenter ID to total length
- outBuffer.writeByte(length + EncodeConstants.SIZE_OF_INT_IN_BYTES);
+ @Override
+ protected final void serializeEntry(final E entry, final M mask, final ByteBuf outBuffer) {
+ outBuffer.writeInt(experimenterId);
+ serializeEntryContent(entry, mask, outBuffer);
}
/**
- * Get experimenter id.
+ * Extract the corresponding entry from a match.
*
- * @return experimenter match entry id
+ * @param entry entry to serialize
+ * @param outBuffer output buffer
*/
- protected abstract long getExperimenterId();
+ protected abstract void serializeEntryContent(@NonNull E entry, @Nullable M mask, @NonNull ByteBuf outBuffer);
}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
+import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchArbitraryBitMask;
+
+abstract class AbstractIpv4PolymorphicEntrySerializer
+ extends AbstractPolymorphicEntrySerializer<Ipv4MatchArbitraryBitMask, Ipv4Match, Ipv4Prefix, DottedQuad> {
+
+ AbstractIpv4PolymorphicEntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(oxmClassCode, oxmFieldCode, EncodeConstants.SIZE_OF_INT_IN_BYTES, Ipv4MatchArbitraryBitMask.class,
+ Ipv4Match.class, Ipv4Prefix.class, DottedQuad.class);
+ }
+
+ @Override
+ final boolean useArbitraryEntry(final Ipv4MatchArbitraryBitMask arbitraryMatch) {
+ return extractArbitraryEntryAddress(arbitraryMatch) != null;
+ }
+
+ @Override
+ final Integer extractNormalEntryMask(final Ipv4Prefix entry) {
+ return IpConversionUtil.hasIpv4Prefix(entry);
+ }
+
+ @Override
+ final void serializeArbitraryEntry(final Ipv4MatchArbitraryBitMask arbitraryMatch, final DottedQuad mask,
+ final ByteBuf outBuffer) {
+ writeIpv4Address(extractArbitraryEntryAddress(arbitraryMatch), outBuffer);
+ if (mask != null) {
+ writeMask(IpConversionUtil.convertArbitraryMaskToByteArray(mask), outBuffer,
+ EncodeConstants.SIZE_OF_INT_IN_BYTES);
+ }
+ }
+
+ @Override
+ final void serializeNormalEntry(final Ipv4Prefix entry, final Integer mask, final ByteBuf outBuffer) {
+ writeIpv4Prefix(entry, mask, outBuffer);
+ }
+
+ abstract Ipv4Address extractArbitraryEntryAddress(@NonNull Ipv4MatchArbitraryBitMask arbitraryMatch);
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
+import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
+
+public abstract class AbstractIpv4PrefixEntrySerializer extends AbstractMatchEntrySerializer<Ipv4Prefix, Integer> {
+ protected AbstractIpv4PrefixEntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(new ConstantHeaderWriter<>(oxmClassCode, oxmFieldCode, EncodeConstants.SIZE_OF_INT_IN_BYTES));
+ }
+
+ @Override
+ protected final Integer extractEntryMask(final Ipv4Prefix entry) {
+ return IpConversionUtil.hasIpv4Prefix(entry);
+ }
+
+ @Override
+ protected final void serializeEntry(final Ipv4Prefix entry, final Integer mask, final ByteBuf outBuffer) {
+ writeIpv4Prefix(entry, mask, outBuffer);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
+import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6MatchArbitraryBitMask;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.opendaylight.ipv6.arbitrary.bitmask.fields.rev160224.Ipv6ArbitraryMask;
+
+abstract class AbstractIpv6PolymorphicEntrySerializer extends
+ AbstractPolymorphicEntrySerializer<Ipv6MatchArbitraryBitMask, Ipv6Match, Ipv6Prefix, Ipv6ArbitraryMask> {
+
+ AbstractIpv6PolymorphicEntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(oxmClassCode, oxmFieldCode, EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES,
+ Ipv6MatchArbitraryBitMask.class, Ipv6Match.class, Ipv6Prefix.class, Ipv6ArbitraryMask.class);
+ }
+
+ @Override
+ final boolean useArbitraryEntry(final Ipv6MatchArbitraryBitMask arbitraryMatch) {
+ return extractArbitraryEntryAddress(arbitraryMatch) != null;
+ }
+
+ @Override
+ final Integer extractNormalEntryMask(final Ipv6Prefix entry) {
+ return IpConversionUtil.hasIpv6Prefix(entry);
+ }
+
+ @Override
+ final void serializeArbitraryEntry(final Ipv6MatchArbitraryBitMask arbitraryMatch, final Ipv6ArbitraryMask mask,
+ final ByteBuf outBuffer) {
+ writeIpv6Address(extractArbitraryEntryAddress(arbitraryMatch), outBuffer);
+ if (mask != null) {
+ writeMask(IpConversionUtil.convertIpv6ArbitraryMaskToByteArray(mask), outBuffer,
+ EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES);
+ }
+ }
+
+ @Override
+ final void serializeNormalEntry(final Ipv6Prefix entry, final Integer mask, final ByteBuf outBuffer) {
+ writeIpv6Prefix(entry, mask, outBuffer);
+ }
+
+ abstract Ipv6Address extractArbitraryEntryAddress(@NonNull Ipv6MatchArbitraryBitMask arbitraryMatch);
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+
+public abstract class AbstractMacAddressEntrySerializer extends AbstractPrimitiveEntrySerializer<MacAddress> {
+ protected AbstractMacAddressEntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(oxmClassCode, oxmFieldCode, EncodeConstants.MAC_ADDRESS_LENGTH);
+ }
+
+ @Override
+ protected final void serializeEntry(final MacAddress entry, final ByteBuf outBuffer) {
+ writeMacAddress(entry, outBuffer);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
+import org.opendaylight.openflowjava.util.ByteBufUtils;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.MacAddressFilter;
+
+public abstract class AbstractMacAddressFilterEntrySerializer<E extends MacAddressFilter>
+ extends AbstractMatchEntrySerializer<E, MacAddress> {
+
+ protected AbstractMacAddressFilterEntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(new ConstantHeaderWriter<>(oxmClassCode, oxmFieldCode, EncodeConstants.MAC_ADDRESS_LENGTH));
+ }
+
+ @Override
+ protected final MacAddress extractEntryMask(final E entry) {
+ return entry.getMask();
+ }
+
+ @Override
+ protected final void serializeEntry(final E entry, final MacAddress mask, final ByteBuf outBuffer) {
+ writeMacAddress(entry.getAddress(), outBuffer);
+ if (mask != null) {
+ writeMask(ByteBufUtils.macAddressToBytes(mask.getValue()), outBuffer, EncodeConstants.MAC_ADDRESS_LENGTH);
+ }
+ }
+}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
-import java.util.Iterator;
-import org.opendaylight.openflowjava.protocol.api.extensibility.HeaderSerializer;
+import io.netty.buffer.Unpooled;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowplugin.api.openflow.protocol.serialization.MatchEntrySerializer;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.MatchConvertorUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
-public abstract class AbstractMatchEntrySerializer implements HeaderSerializer<Match>, MatchEntrySerializer {
+/**
+ * Abstract base class for conveniently implementing {@link MatchEntrySerializer}.
+ *
+ * @param <E> Match entry type
+ * @param <M> Match entry mask type, use Void a mask is not applicable
+ */
+public abstract class AbstractMatchEntrySerializer<E, M> implements MatchEntrySerializer {
+ /**
+ * Base class supporting writing out a particular match entry's header. This class should be subclassed only
+ * in case the header contents depends on the match entry content in a more dynamic fashion than the presence
+ * or absence of the mask. In all other cases using {@link ConstantHeaderWriter} is preferable.
+ *
+ * @param <E> Match entry type
+ * @param <M> Match entry mask type, use Void a mask is not applicable
+ */
+ protected abstract static class HeaderWriter<E, M> {
+
+ /**
+ * Write out the header for a particular entry, containing specified mask, to the provided output buffer.
+ *
+ * @param entry match entry for which to write the header
+ * @param mask mask as extracted from the match entry, may be null
+ * @param outBuffer output buffer
+ */
+ protected abstract void writeHeader(@NonNull E entry, @Nullable M mask, @NonNull ByteBuf outBuffer);
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- serializeHeader(match, outBuffer);
+ protected static final void writeHeader(final int oxmClassCode, final int oxmFieldCode, final int valueLength,
+ final boolean hasMask, final ByteBuf outBuffer) {
+ writeHeader(oxmClassCode, oxmFieldCode, valueLength, hasMask, 0, outBuffer);
+ }
+
+ protected static final void writeHeader(final int oxmClassCode, final int oxmFieldCode, final int valueLength,
+ final boolean hasMask, final int extraLength, final ByteBuf outBuffer) {
+ outBuffer.writeShort(oxmClassCode);
+
+ int fieldAndMask = oxmFieldCode << 1;
+ int length = valueLength;
+
+ if (hasMask) {
+ fieldAndMask |= 1;
+ length *= 2;
+ }
+
+ outBuffer.writeByte(fieldAndMask);
+ outBuffer.writeByte(length + extraLength);
+ }
}
- @Override
- public void serializeHeader(Match match, ByteBuf outBuffer) {
- outBuffer.writeShort(getOxmClassCode());
+ /**
+ * Utility {@link HeaderWriter} optimized for cases where the header does not depend on the actual entry content
+ * beyond presence/absence of a mask. This class pre-computes the possible header values for masked/unmasked cases
+ * and stores them internally for reuse.
+ *
+ * @param <E> Match entry type
+ * @param <M> Match entry mask type, use Void a mask is not applicable
+ */
+ /*
+ * Implementation note:
+ *
+ * While it looks like we could save some memory by refactoring this class into two instances for the non-mask
+ * and mask values, that actually would result in increased memory footprint because the JVM object header is
+ * larger than the state we keep. We would also require another reference field in the serializer itself, which
+ * would expand the size of that object, negating the benefit.
+ *
+ * Another refactor would see the case where an entry cannot have a mask split out into a separate class, making
+ * that specialized object smaller and not contain the null check in writeHeader(). This can be considered, but
+ * has to be thoroughly benchmarked with representative data, because introducing another implementation means
+ * calls to writeHeader() are no longer monomorphic and are not as readily devirtualizable -- which has performance
+ * implications which can easily negate any behefits from the specialization.
+ */
+ protected static final class ConstantHeaderWriter<E, M> extends HeaderWriter<E, M> {
+ private final int withMask;
+ private final int withoutMask;
- int fieldAndMask = getOxmFieldCode() << 1;
- int length = getValueLength();
+ protected ConstantHeaderWriter(final int withMask, final int withoutMask) {
+ this.withMask = withMask;
+ this.withoutMask = withoutMask;
+ }
- if (getHasMask(match)) {
- fieldAndMask |= 1;
- length *= 2;
+ protected ConstantHeaderWriter(final int oxmClassCode, final int oxmFieldCode, final int valueLength) {
+ this(oxmClassCode, oxmFieldCode, valueLength, 0);
}
- outBuffer.writeByte(fieldAndMask);
- outBuffer.writeByte(length);
+ protected ConstantHeaderWriter(final int oxmClassCode, final int oxmFieldCode, final int valueLength,
+ final int extraLength) {
+ this(constructHeader(oxmClassCode, oxmFieldCode, valueLength, extraLength, true),
+ constructHeader(oxmClassCode, oxmFieldCode, valueLength, extraLength, false));
+ }
+
+ @Override
+ protected void writeHeader(final E entry, final M mask, final ByteBuf outBuffer) {
+ outBuffer.writeInt(mask != null ? withMask : withoutMask);
+ }
+
+ private static int constructHeader(final int oxmClassCode, final int oxmFieldCode, final int valueLength,
+ final int extraLength, final boolean withMask) {
+ final ByteBuf buf = Unpooled.buffer();
+ writeHeader(oxmClassCode, oxmFieldCode, valueLength, withMask, extraLength, buf);
+ final int header = buf.readInt();
+ verify(buf.readableBytes() == 0);
+ return header;
+ }
+ }
+
+ private final HeaderWriter<E, M> headerWriter;
+
+ protected AbstractMatchEntrySerializer(final HeaderWriter<E, M> headerWriter) {
+ this.headerWriter = requireNonNull(headerWriter);
+ }
+
+ protected AbstractMatchEntrySerializer(final int oxmClassCode, final int oxmFieldCode, final int valueLength) {
+ this(new ConstantHeaderWriter<>(oxmClassCode, oxmFieldCode, valueLength));
+ }
+
+ @Override
+ public final void serializeIfPresent(final Match match, final ByteBuf outBuffer) {
+ final E entry = extractEntry(match);
+ if (entry != null) {
+ final M mask = extractEntryMask(entry);
+ headerWriter.writeHeader(entry, mask, outBuffer);
+ serializeEntry(entry, mask, outBuffer);
+ }
}
/**
* @param outBuffer output buffer
* @param length mask length
*/
- protected static void writeMask(byte[] mask, ByteBuf outBuffer, int length) {
- if (mask == null) {
- return;
- }
-
- if (mask.length != length) {
- throw new IllegalArgumentException("incorrect length of mask: "
- + mask.length + ", expected: " + length);
+ protected static void writeMask(final byte[] mask, final ByteBuf outBuffer, final int length) {
+ if (mask != null) {
+ if (mask.length != length) {
+ throw new IllegalArgumentException("incorrect length of mask: " + mask.length + ", expected: "
+ + length);
+ }
+ outBuffer.writeBytes(mask);
}
-
- outBuffer.writeBytes(mask);
}
/**
* @param outBuffer output buffer
*/
protected static void writeMacAddress(final MacAddress address, final ByteBuf outBuffer) {
- outBuffer.writeBytes(IetfYangUtil.INSTANCE.bytesFor(address)); // 48 b + mask [OF 1.3.2 spec]
+ // 48 b + mask [OF 1.3.2 spec]
+ outBuffer.writeBytes(IetfYangUtil.INSTANCE.bytesFor(address));
}
/**
* @param prefix Ipv4 prefix
* @param outBuffer output buffer
*/
- protected static void writeIpv4Prefix(final Ipv4Prefix prefix, final ByteBuf outBuffer) {
- // Split address to IP and mask
- final Iterator<String> addressParts = IpConversionUtil.splitToParts(prefix);
-
+ protected static void writeIpv4Prefix(final @NonNull Ipv4Prefix prefix, final @Nullable Integer mask,
+ final @NonNull ByteBuf outBuffer) {
// Write address part of prefix
- writeIpv4Address(new Ipv4Address(addressParts.next()), outBuffer);
+ writeIpv4Address(IetfInetUtil.INSTANCE.ipv4AddressFrom(prefix), outBuffer);
// If prefix had mask, also write prefix
- final byte[] mask = MatchConvertorUtil.extractIpv4Mask(addressParts);
if (mask != null) {
- writeMask(mask, outBuffer, EncodeConstants.GROUPS_IN_IPV4_ADDRESS);
+ outBuffer.writeInt(IpConversionUtil.maskForIpv4Prefix(mask));
}
}
* @param prefix Ipv6 prefix
* @param outBuffer output buffer
*/
- protected static void writeIpv6Prefix(final Ipv6Prefix prefix, final ByteBuf outBuffer) {
+ protected static void writeIpv6Prefix(final @NonNull Ipv6Prefix prefix, final @Nullable Integer mask,
+ final @NonNull ByteBuf outBuffer) {
// Write address part of prefix
writeIpv6Address(IpConversionUtil.extractIpv6Address(prefix), outBuffer);
// If prefix had mask, also write prefix
- final Integer mask = IpConversionUtil.hasIpv6Prefix(prefix);
if (mask != null) {
writeMask(IpConversionUtil.convertIpv6PrefixToByteArray(mask), outBuffer,
EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES);
}
/**
- * Has mask getter.
+ * Extract the corresponding entry from a match.
*
* @param match Openflow match
- * @return if field has or has not mask
+ * @return Entry, null if not present
*/
- protected abstract boolean getHasMask(Match match);
+ protected abstract @Nullable E extractEntry(Match match);
/**
- * Oxm field numeric representation.
+ * Extract the mask contained in an entry.
*
- * @return numeric representation of oxm_field
+ * @param entry entry to examine
+ * @return Mask, null if not present
*/
- protected abstract int getOxmFieldCode();
+ protected abstract @Nullable M extractEntryMask(@NonNull E entry);
/**
- * Oxm class code.
+ * Extract the corresponding entry from a match.
*
- * @return numeric representation of oxm_class
- */
- protected abstract int getOxmClassCode();
-
- /**
- * Get value length.
- *
- * @return match entry value length (without mask length)
+ * @param entry entry to serialize
+ * @param mask mask as extracted from entry
+ * @param outBuffer output buffer
*/
- protected abstract int getValueLength();
+ protected abstract void serializeEntry(@NonNull E entry, @Nullable M mask, @NonNull ByteBuf outBuffer);
}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import static java.util.Objects.requireNonNull;
+
+import io.netty.buffer.ByteBuf;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
+
+/**
+ * Abstract base AbstractMatchEntrySerializer to deal with IPv4/IPv6 source/destination polymorphism.
+ */
+abstract class AbstractPolymorphicEntrySerializer<A extends Layer3Match, N extends Layer3Match, E, M>
+ extends AbstractMatchEntrySerializer<Object, Object> {
+ private final Class<A> arbitraryClass;
+ private final Class<N> normalClass;
+ private final Class<E> entryClass;
+ private final Class<M> arbitraryMaskClass;
+
+ AbstractPolymorphicEntrySerializer(final int oxmClassCode, final int oxmFieldCode, final int valueLength,
+ final Class<A> arbitraryClass, final Class<N> normalClass, final Class<E> entryClass,
+ final Class<M> arbitraryMaskClass) {
+ super(new ConstantHeaderWriter<>(oxmClassCode, oxmFieldCode, valueLength));
+ this.arbitraryClass = requireNonNull(arbitraryClass);
+ this.normalClass = requireNonNull(normalClass);
+ this.entryClass = requireNonNull(entryClass);
+ this.arbitraryMaskClass = requireNonNull(arbitraryMaskClass);
+ }
+
+ @Override
+ protected final Object extractEntry(final Match match) {
+ final Layer3Match layer3Match = match.getLayer3Match();
+ if (normalClass.isInstance(layer3Match)) {
+ return extractNormalEntry(normalClass.cast(layer3Match));
+ } else if (arbitraryClass.isInstance(layer3Match) && useArbitraryEntry(arbitraryClass.cast(layer3Match))) {
+ return layer3Match;
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ protected final Object extractEntryMask(final Object entry) {
+ if (arbitraryClass.isInstance(entry)) {
+ return extractArbitraryEntryMask(arbitraryClass.cast(entry));
+ }
+ return extractNormalEntryMask(entryClass.cast(entry));
+ }
+
+ @Override
+ protected final void serializeEntry(final Object entry, final Object mask, final ByteBuf outBuffer) {
+ if (entryClass.isInstance(entry)) {
+ serializeNormalEntry(entryClass.cast(entry), (Integer) mask, outBuffer);
+ } else {
+ serializeArbitraryEntry(arbitraryClass.cast(entry), arbitraryMaskClass.cast(mask), outBuffer);
+ }
+ }
+
+ abstract boolean useArbitraryEntry(@NonNull A arbitraryMatch);
+
+ abstract @Nullable E extractNormalEntry(@NonNull N normalMatch);
+
+ abstract @Nullable M extractArbitraryEntryMask(@NonNull A arbitraryMatch);
+
+ abstract @Nullable Integer extractNormalEntryMask(@NonNull E entry);
+
+ abstract void serializeArbitraryEntry(@NonNull A arbitraryMatch, @Nullable M mask, @NonNull ByteBuf outBuffer);
+
+ abstract void serializeNormalEntry(@NonNull E entry, @Nullable Integer mask, @NonNull ByteBuf outBuffer);
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yangtools.yang.common.Uint16;
+
+public abstract class AbstractPortNumberEntrySerializer extends AbstractUint16EntrySerializer {
+ protected AbstractPortNumberEntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(oxmClassCode, oxmFieldCode);
+ }
+
+ @Override
+ protected final Uint16 extractEntry(final Match match) {
+ final PortNumber port = extractPort(match);
+ return port == null ? null : port.getValue();
+ }
+
+ protected abstract @Nullable PortNumber extractPort(Match match);
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.eclipse.jdt.annotation.NonNull;
+
+public abstract class AbstractPrimitiveEntrySerializer<E> extends AbstractMatchEntrySerializer<E, Void> {
+ protected AbstractPrimitiveEntrySerializer(final HeaderWriter<E, Void> headerWriter) {
+ super(headerWriter);
+ }
+
+ protected AbstractPrimitiveEntrySerializer(final int oxmClassCode, final int oxmFieldCode, final int valueLength) {
+ super(oxmClassCode, oxmFieldCode, valueLength);
+ }
+
+ @Override
+ protected final Void extractEntryMask(final E entry) {
+ return null;
+ }
+
+ @Override
+ protected final void serializeEntry(final E entry, final Void mask, final ByteBuf outBuffer) {
+ serializeEntry(entry, outBuffer);
+ }
+
+ protected abstract void serializeEntry(@NonNull E entry, @NonNull ByteBuf outBuffer);
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
+import org.opendaylight.yangtools.yang.common.Uint16;
+
+public abstract class AbstractUint16EntrySerializer extends AbstractPrimitiveEntrySerializer<Uint16> {
+ protected AbstractUint16EntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(oxmClassCode, oxmFieldCode, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
+ }
+
+ @Override
+ protected final void serializeEntry(final Uint16 entry, final ByteBuf outBuffer) {
+ outBuffer.writeShort(entry.shortValue());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
+import org.opendaylight.yangtools.yang.common.Uint32;
+
+public abstract class AbstractUint32EntrySerializer extends AbstractPrimitiveEntrySerializer<Uint32> {
+ protected AbstractUint32EntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(oxmClassCode, oxmFieldCode, EncodeConstants.SIZE_OF_INT_IN_BYTES);
+ }
+
+ @Override
+ protected final void serializeEntry(final Uint32 entry, final ByteBuf outBuffer) {
+ outBuffer.writeInt(entry.intValue());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Pantheon Technologies s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
+
+import io.netty.buffer.ByteBuf;
+import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
+import org.opendaylight.yangtools.yang.common.Uint8;
+
+public abstract class AbstractUint8EntrySerializer extends AbstractPrimitiveEntrySerializer<Uint8> {
+ protected AbstractUint8EntrySerializer(final int oxmClassCode, final int oxmFieldCode) {
+ super(oxmClassCode, oxmFieldCode, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
+ }
+
+ @Override
+ protected final void serializeEntry(final Uint8 entry, final ByteBuf outBuffer) {
+ outBuffer.writeByte(entry.byteValue());
+ }
+}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.ArpMatch;
+import org.opendaylight.yangtools.yang.common.Uint16;
-public class ArpOpEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(((ArpMatch) match.getLayer3Match()).getArpOp().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof ArpMatch
- && ((ArpMatch) match.getLayer3Match()).getArpOp() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ARP_OP;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class ArpOpEntrySerializer extends AbstractUint16EntrySerializer {
+ public ArpOpEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_OP);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected Uint16 extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof ArpMatch ? ((ArpMatch) l3Match).getArpOp() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowjava.util.ByteBufUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.arp.match.fields.ArpSourceHardwareAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.ArpMatch;
-public class ArpSourceHardwareAddressEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- final ArpSourceHardwareAddress arpSourceHardwareAddress =
- ((ArpMatch) match.getLayer3Match()).getArpSourceHardwareAddress();
- writeMacAddress(arpSourceHardwareAddress.getAddress(), outBuffer);
-
- if (getHasMask(match)) {
- writeMask(ByteBufUtils.macAddressToBytes(
- arpSourceHardwareAddress.getMask().getValue()),
- outBuffer,
- getValueLength());
- }
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof ArpMatch
- && ((ArpMatch) match.getLayer3Match()).getArpSourceHardwareAddress() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return ((ArpMatch) match.getLayer3Match()).getArpSourceHardwareAddress().getMask() != null;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ARP_SHA;
+public class ArpSourceHardwareAddressEntrySerializer
+ extends AbstractMacAddressFilterEntrySerializer<ArpSourceHardwareAddress> {
+ public ArpSourceHardwareAddressEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_SHA);
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ protected ArpSourceHardwareAddress extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof ArpMatch ? ((ArpMatch) l3Match).getArpSourceHardwareAddress() : null;
}
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.MAC_ADDRESS_LENGTH;
- }
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.ArpMatch;
-public class ArpSourceTransportAddressEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- writeIpv4Prefix(((ArpMatch) match.getLayer3Match()).getArpSourceTransportAddress(), outBuffer);
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof ArpMatch
- && ((ArpMatch) match.getLayer3Match()).getArpSourceTransportAddress() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return IpConversionUtil.hasIpv4Prefix(((ArpMatch) match.getLayer3Match()).getArpSourceTransportAddress())
- != null;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ARP_SPA;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class ArpSourceTransportAddressEntrySerializer extends AbstractIpv4PrefixEntrySerializer {
+ public ArpSourceTransportAddressEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_SPA);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ protected Ipv4Prefix extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof ArpMatch ? ((ArpMatch) l3Match).getArpSourceTransportAddress() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowjava.util.ByteBufUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.arp.match.fields.ArpTargetHardwareAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.ArpMatch;
-public class ArpTargetHardwareAddressEntrySerializer extends AbstractMatchEntrySerializer {
+public class ArpTargetHardwareAddressEntrySerializer
+ extends AbstractMacAddressFilterEntrySerializer<ArpTargetHardwareAddress> {
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- final ArpTargetHardwareAddress arpTargetHardwareAddress =
- ((ArpMatch) match.getLayer3Match()).getArpTargetHardwareAddress();
- writeMacAddress(arpTargetHardwareAddress.getAddress(), outBuffer);
-
- if (getHasMask(match)) {
- writeMask(ByteBufUtils.macAddressToBytes(
- arpTargetHardwareAddress.getMask().getValue()),
- outBuffer,
- getValueLength());
- }
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof ArpMatch
- && ((ArpMatch) match.getLayer3Match()).getArpTargetHardwareAddress() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return ((ArpMatch) match.getLayer3Match()).getArpTargetHardwareAddress().getMask() != null;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ARP_THA;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ public ArpTargetHardwareAddressEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_THA);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.MAC_ADDRESS_LENGTH;
+ protected ArpTargetHardwareAddress extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof ArpMatch ? ((ArpMatch) l3Match).getArpTargetHardwareAddress() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.ArpMatch;
-public class ArpTargetTransportAddressEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- writeIpv4Prefix(((ArpMatch) match.getLayer3Match()).getArpTargetTransportAddress(), outBuffer);
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof ArpMatch
- && ((ArpMatch) match.getLayer3Match()).getArpTargetTransportAddress() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return IpConversionUtil.hasIpv4Prefix(((ArpMatch) match.getLayer3Match()).getArpTargetTransportAddress())
- != null;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ARP_TPA;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class ArpTargetTransportAddressEntrySerializer extends AbstractIpv4PrefixEntrySerializer {
+ public ArpTargetTransportAddressEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ARP_TPA);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ protected Ipv4Prefix extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof ArpMatch ? ((ArpMatch) l3Match).getArpTargetTransportAddress() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowjava.util.ByteBufUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestination;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatch;
-public class EthernetDestinationEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- writeMacAddress(match.getEthernetMatch().getEthernetDestination().getAddress(), outBuffer);
-
- if (getHasMask(match)) {
- writeMask(ByteBufUtils.macAddressToBytes(
- match.getEthernetMatch().getEthernetDestination().getMask().getValue()),
- outBuffer,
- getValueLength());
- }
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getEthernetMatch() != null && match.getEthernetMatch().getEthernetDestination() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return match.getEthernetMatch().getEthernetDestination().getMask() != null;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ETH_DST;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class EthernetDestinationEntrySerializer extends AbstractMacAddressFilterEntrySerializer<EthernetDestination> {
+ public EthernetDestinationEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ETH_DST);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.MAC_ADDRESS_LENGTH;
+ protected EthernetDestination extractEntry(final Match match) {
+ final EthernetMatch ethMatch = match.getEthernetMatch();
+ return ethMatch == null ? null : ethMatch.getEthernetDestination();
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowjava.util.ByteBufUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetSource;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatch;
-public class EthernetSourceEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- writeMacAddress(match.getEthernetMatch().getEthernetSource().getAddress(), outBuffer);
-
- if (getHasMask(match)) {
- writeMask(ByteBufUtils.macAddressToBytes(
- match.getEthernetMatch().getEthernetSource().getMask().getValue()),
- outBuffer,
- getValueLength());
- }
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getEthernetMatch() != null && match.getEthernetMatch().getEthernetSource() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return match.getEthernetMatch().getEthernetSource().getMask() != null;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ETH_SRC;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class EthernetSourceEntrySerializer extends AbstractMacAddressFilterEntrySerializer<EthernetSource> {
+ public EthernetSourceEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ETH_SRC);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.MAC_ADDRESS_LENGTH;
+ protected EthernetSource extractEntry(final Match match) {
+ final EthernetMatch ethMatch = match.getEthernetMatch();
+ return ethMatch == null ? null : ethMatch.getEthernetSource();
}
}
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatch;
-public class EthernetTypeEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(match.getEthernetMatch().getEthernetType().getType().getValue().shortValue());
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getEthernetMatch() != null && match.getEthernetMatch().getEthernetType() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ETH_TYPE;
+public class EthernetTypeEntrySerializer extends AbstractPrimitiveEntrySerializer<EthernetType> {
+ public EthernetTypeEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ETH_TYPE,
+ EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ protected EthernetType extractEntry(final Match match) {
+ final EthernetMatch ethMatch = match.getEthernetMatch();
+ return ethMatch == null ? null : ethMatch.getEthernetType();
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected void serializeEntry(final EthernetType entry, final ByteBuf outBuffer) {
+ outBuffer.writeShort(entry.getType().getValue().shortValue());
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv4Match;
+import org.opendaylight.yangtools.yang.common.Uint8;
-public class Icmpv4CodeEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeByte(match.getIcmpv4Match().getIcmpv4Code().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getIcmpv4Match() != null && match.getIcmpv4Match().getIcmpv4Code() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ICMPV4_CODE;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class Icmpv4CodeEntrySerializer extends AbstractUint8EntrySerializer {
+ public Icmpv4CodeEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ICMPV4_CODE);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
+ protected Uint8 extractEntry(final Match match) {
+ final Icmpv4Match icmpMatch = match.getIcmpv4Match();
+ return icmpMatch == null ? null : icmpMatch.getIcmpv4Code();
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv4Match;
+import org.opendaylight.yangtools.yang.common.Uint8;
-public class Icmpv4TypeEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeByte(match.getIcmpv4Match().getIcmpv4Type().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getIcmpv4Match() != null && match.getIcmpv4Match().getIcmpv4Type() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ICMPV4_TYPE;
+public class Icmpv4TypeEntrySerializer extends AbstractUint8EntrySerializer {
+ public Icmpv4TypeEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ICMPV4_TYPE);
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ protected Uint8 extractEntry(final Match match) {
+ final Icmpv4Match icmpMatch = match.getIcmpv4Match();
+ return icmpMatch == null ? null : icmpMatch.getIcmpv4Type();
}
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
- }
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv6Match;
+import org.opendaylight.yangtools.yang.common.Uint8;
-public class Icmpv6CodeEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeByte(match.getIcmpv6Match().getIcmpv6Code().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getIcmpv6Match() != null && match.getIcmpv6Match().getIcmpv6Code() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ICMPV6_CODE;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class Icmpv6CodeEntrySerializer extends AbstractUint8EntrySerializer {
+ public Icmpv6CodeEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ICMPV6_CODE);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
+ protected Uint8 extractEntry(final Match match) {
+ final Icmpv6Match icmpMatch = match.getIcmpv6Match();
+ return icmpMatch == null ? null : icmpMatch.getIcmpv6Code();
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv6Match;
+import org.opendaylight.yangtools.yang.common.Uint8;
-public class Icmpv6TypeEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeByte(match.getIcmpv6Match().getIcmpv6Type().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getIcmpv6Match() != null && match.getIcmpv6Match().getIcmpv6Type() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.ICMPV6_TYPE;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class Icmpv6TypeEntrySerializer extends AbstractUint8EntrySerializer {
+ public Icmpv6TypeEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.ICMPV6_TYPE);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
+ protected Uint8 extractEntry(final Match match) {
+ final Icmpv6Match icmpMatch = match.getIcmpv6Match();
+ return icmpMatch == null ? null : icmpMatch.getIcmpv6Type();
}
}
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
-public class InPhyPortEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeInt(InventoryDataServiceUtil.portNumberfromNodeConnectorId(
- OpenflowVersion.OF13,
- match.getInPhyPort()).intValue());
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getInPhyPort() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IN_PHY_PORT;
+public class InPhyPortEntrySerializer extends AbstractPrimitiveEntrySerializer<NodeConnectorId> {
+ public InPhyPortEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IN_PHY_PORT,
+ EncodeConstants.SIZE_OF_INT_IN_BYTES);
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ protected NodeConnectorId extractEntry(final Match match) {
+ return match.getInPhyPort();
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ protected void serializeEntry(final NodeConnectorId entry, final ByteBuf outBuffer) {
+ outBuffer.writeInt(
+ InventoryDataServiceUtil.portNumberfromNodeConnectorId(OpenflowVersion.OF13, entry).intValue());
}
}
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
import org.opendaylight.yangtools.yang.common.Uint32;
-public class InPortEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- Uint32 value = InventoryDataServiceUtil.portNumberfromNodeConnectorId(
- OpenflowVersion.OF13,
- match.getInPort().getValue());
- if (value == null) {
- throw new IllegalArgumentException("Not a valid port number: " + match.getInPort().getValue());
- }
- outBuffer.writeInt(value.intValue());
+public class InPortEntrySerializer extends AbstractPrimitiveEntrySerializer<NodeConnectorId> {
+ public InPortEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IN_PORT,EncodeConstants.SIZE_OF_INT_IN_BYTES);
}
@Override
- public boolean matchTypeCheck(final Match match) {
- return match.getInPort() != null;
+ protected NodeConnectorId extractEntry(final Match match) {
+ return match.getInPort();
}
@Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IN_PORT;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ protected void serializeEntry(final NodeConnectorId entry, final ByteBuf outBuffer) {
+ Uint32 value = InventoryDataServiceUtil.portNumberfromNodeConnectorId(OpenflowVersion.OF13, entry.getValue());
+ if (value == null) {
+ throw new IllegalArgumentException("Not a valid port number: " + entry.getValue());
+ }
+ outBuffer.writeInt(value.intValue());
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Dscp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatch;
-public class IpDscpEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeByte(match.getIpMatch().getIpDscp().getValue().toJava());
+public class IpDscpEntrySerializer extends AbstractPrimitiveEntrySerializer<Dscp> {
+ public IpDscpEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IP_DSCP, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
}
@Override
- public boolean matchTypeCheck(final Match match) {
- return match.getIpMatch() != null && match.getIpMatch().getIpDscp() != null;
+ protected Dscp extractEntry(final Match match) {
+ final IpMatch ipMatch = match.getIpMatch();
+ return ipMatch == null ? null : ipMatch.getIpDscp();
}
@Override
- protected boolean getHasMask(final Match match) {
- return false;
+ protected void serializeEntry(final Dscp entry, final ByteBuf outBuffer) {
+ outBuffer.writeByte(entry.getValue().byteValue());
}
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IP_DSCP;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
- }
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatch;
+import org.opendaylight.yangtools.yang.common.Uint8;
-public class IpEcnEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeByte(match.getIpMatch().getIpEcn().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getIpMatch() != null && match.getIpMatch().getIpEcn() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
+public class IpEcnEntrySerializer extends AbstractUint8EntrySerializer {
+ public IpEcnEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IP_ECN);
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IP_ECN;
+ protected Uint8 extractEntry(final Match match) {
+ final IpMatch ipMatch = match.getIpMatch();
+ return ipMatch == null ? null : ipMatch.getIpEcn();
}
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
- }
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatch;
+import org.opendaylight.yangtools.yang.common.Uint8;
-public class IpProtoEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- // TODO: What is getIpMatch().getIpProto()? Fix models probably
- outBuffer.writeByte(match.getIpMatch().getIpProtocol().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getIpMatch() != null && match.getIpMatch().getIpProtocol() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IP_PROTO;
+public class IpProtoEntrySerializer extends AbstractUint8EntrySerializer {
+ public IpProtoEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IP_PROTO);
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
+ protected Uint8 extractEntry(final Match match) {
+ // TODO: What is getIpMatch().getIpProto()? Fix models probably
+ final IpMatch ipMatch = match.getIpMatch();
+ return ipMatch == null ? null : ipMatch.getIpProtocol();
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchArbitraryBitMask;
-public class Ipv4DestinationEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
-
- if (isPrefix(match)) {
- writeIpv4Prefix(((Ipv4Match) match.getLayer3Match()).getIpv4Destination(), outBuffer);
- } else if (isArbitrary(match)) {
- final Ipv4MatchArbitraryBitMask ipv4 = (Ipv4MatchArbitraryBitMask) match.getLayer3Match();
- writeIpv4Address(ipv4.getIpv4DestinationAddressNoMask(), outBuffer);
-
- if (getHasMask(match)) {
- writeMask(IpConversionUtil.convertArbitraryMaskToByteArray(ipv4.getIpv4DestinationArbitraryBitmask()),
- outBuffer,
- getValueLength());
- }
- }
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- if (isPrefix(match)) {
- return match.getLayer3Match() != null
- && ((Ipv4Match) match.getLayer3Match()).getIpv4Destination() != null;
- } else if (isArbitrary(match)) {
- return match.getLayer3Match() != null
- && ((Ipv4MatchArbitraryBitMask) match.getLayer3Match()).getIpv4DestinationAddressNoMask() != null;
- }
-
- return false;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- if (isPrefix(match)) {
- return IpConversionUtil.hasIpv4Prefix(((Ipv4Match) match.getLayer3Match()).getIpv4Destination()) != null;
- } else if (isArbitrary(match)) {
- return ((Ipv4MatchArbitraryBitMask) match.getLayer3Match()).getIpv4DestinationArbitraryBitmask() != null;
- }
-
- return false;
- }
-
- private static boolean isPrefix(Match match) {
- return match.getLayer3Match() instanceof Ipv4Match;
- }
-
- private static boolean isArbitrary(Match match) {
- return match.getLayer3Match() instanceof Ipv4MatchArbitraryBitMask;
+public class Ipv4DestinationEntrySerializer extends AbstractIpv4PolymorphicEntrySerializer {
+ public Ipv4DestinationEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV4_DST);
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV4_DST;
+ Ipv4Prefix extractNormalEntry(final Ipv4Match normalMatch) {
+ return normalMatch.getIpv4Destination();
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ DottedQuad extractArbitraryEntryMask(final Ipv4MatchArbitraryBitMask arbitraryMatch) {
+ return arbitraryMatch.getIpv4DestinationArbitraryBitmask();
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ Ipv4Address extractArbitraryEntryAddress(final Ipv4MatchArbitraryBitMask arbitraryMatch) {
+ return arbitraryMatch.getIpv4DestinationAddressNoMask();
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchArbitraryBitMask;
-public class Ipv4SourceEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
-
- if (isPrefix(match)) {
- writeIpv4Prefix(((Ipv4Match) match.getLayer3Match()).getIpv4Source(), outBuffer);
- } else if (isArbitrary(match)) {
- final Ipv4MatchArbitraryBitMask ipv4 = (Ipv4MatchArbitraryBitMask) match.getLayer3Match();
- writeIpv4Address(ipv4.getIpv4SourceAddressNoMask(), outBuffer);
-
- if (getHasMask(match)) {
- writeMask(IpConversionUtil.convertArbitraryMaskToByteArray(ipv4.getIpv4SourceArbitraryBitmask()),
- outBuffer,
- getValueLength());
- }
- }
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- if (isPrefix(match)) {
- return match.getLayer3Match() != null
- && ((Ipv4Match) match.getLayer3Match()).getIpv4Source() != null;
- } else if (isArbitrary(match)) {
- return match.getLayer3Match() != null
- && ((Ipv4MatchArbitraryBitMask) match.getLayer3Match()).getIpv4SourceAddressNoMask() != null;
- }
-
- return false;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- if (isPrefix(match)) {
- return IpConversionUtil.hasIpv4Prefix(((Ipv4Match) match.getLayer3Match()).getIpv4Source()) != null;
- } else if (isArbitrary(match)) {
- return ((Ipv4MatchArbitraryBitMask) match.getLayer3Match()).getIpv4SourceArbitraryBitmask() != null;
- }
-
- return false;
- }
-
- private static boolean isPrefix(Match match) {
- return match.getLayer3Match() instanceof Ipv4Match;
- }
-
- private static boolean isArbitrary(Match match) {
- return match.getLayer3Match() instanceof Ipv4MatchArbitraryBitMask;
+public class Ipv4SourceEntrySerializer extends AbstractIpv4PolymorphicEntrySerializer {
+ public Ipv4SourceEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV4_SRC);
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV4_SRC;
+ Ipv4Prefix extractNormalEntry(final Ipv4Match normalMatch) {
+ return normalMatch.getIpv4Source();
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ Ipv4Address extractArbitraryEntryAddress(final Ipv4MatchArbitraryBitMask arbitraryMatch) {
+ return arbitraryMatch.getIpv4SourceAddressNoMask();
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ DottedQuad extractArbitraryEntryMask(final Ipv4MatchArbitraryBitMask arbitraryMatch) {
+ return arbitraryMatch.getIpv4SourceArbitraryBitmask();
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6MatchArbitraryBitMask;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.opendaylight.ipv6.arbitrary.bitmask.fields.rev160224.Ipv6ArbitraryMask;
-public class Ipv6DestinationEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
-
- if (isPrefix(match)) {
- writeIpv6Prefix(((Ipv6Match) match.getLayer3Match()).getIpv6Destination(), outBuffer);
- } else if (isArbitrary(match)) {
- final Ipv6MatchArbitraryBitMask ipv6 = (Ipv6MatchArbitraryBitMask) match.getLayer3Match();
- writeIpv6Address(ipv6.getIpv6DestinationAddressNoMask(), outBuffer);
-
- if (getHasMask(match)) {
- writeMask(IpConversionUtil
- .convertIpv6ArbitraryMaskToByteArray(ipv6.getIpv6DestinationArbitraryBitmask()),
- outBuffer,
- getValueLength());
- }
- }
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- if (isPrefix(match)) {
- return match.getLayer3Match() != null
- && ((Ipv6Match) match.getLayer3Match()).getIpv6Destination() != null;
- } else if (isArbitrary(match)) {
- return match.getLayer3Match() != null
- && ((Ipv6MatchArbitraryBitMask) match.getLayer3Match()).getIpv6DestinationAddressNoMask() != null;
- }
-
- return false;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- if (isPrefix(match)) {
- if (null != IpConversionUtil.hasIpv6Prefix(((Ipv6Match) match.getLayer3Match()).getIpv6Destination())) {
- return IpConversionUtil.extractIpv6Prefix(
- ((Ipv6Match) match.getLayer3Match()).getIpv6Destination()) != null;
- }
- } else if (isArbitrary(match)) {
- return ((Ipv6MatchArbitraryBitMask) match.getLayer3Match()).getIpv6DestinationArbitraryBitmask() != null;
- }
-
- return false;
- }
-
- private static boolean isPrefix(Match match) {
- return match.getLayer3Match() instanceof Ipv6Match;
- }
-
- private static boolean isArbitrary(Match match) {
- return match.getLayer3Match() instanceof Ipv6MatchArbitraryBitMask;
+public class Ipv6DestinationEntrySerializer extends AbstractIpv6PolymorphicEntrySerializer {
+ public Ipv6DestinationEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_DST);
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV6_DST;
+ Ipv6Prefix extractNormalEntry(final Ipv6Match normalMatch) {
+ return normalMatch.getIpv6Destination();
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ Ipv6Address extractArbitraryEntryAddress(final Ipv6MatchArbitraryBitMask arbitraryMatch) {
+ return arbitraryMatch.getIpv6DestinationAddressNoMask();
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES;
+ Ipv6ArbitraryMask extractArbitraryEntryMask(final Ipv6MatchArbitraryBitMask arbitraryMatch) {
+ return arbitraryMatch.getIpv6DestinationArbitraryBitmask();
}
}
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ipv6.match.fields.Ipv6ExtHeader;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
+import org.opendaylight.yangtools.yang.common.Uint16;
-public class Ipv6ExtHeaderEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- final Ipv6ExtHeader ipv6ExtHeader = ((Ipv6Match) match.getLayer3Match()).getIpv6ExtHeader();
- outBuffer.writeShort(ipv6ExtHeader.getIpv6Exthdr().toJava());
-
- if (getHasMask(match)) {
- writeMask(ByteUtil.unsignedShortToBytes(
- ipv6ExtHeader.getIpv6ExthdrMask()),
- outBuffer,
- getValueLength());
- }
+public class Ipv6ExtHeaderEntrySerializer extends AbstractMatchEntrySerializer<Ipv6ExtHeader, Uint16> {
+ public Ipv6ExtHeaderEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_EXTHDR,
+ EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
}
@Override
- public boolean matchTypeCheck(final Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof Ipv6Match
- && ((Ipv6Match) match.getLayer3Match()).getIpv6ExtHeader() != null;
+ protected Ipv6ExtHeader extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof Ipv6Match ? ((Ipv6Match) l3Match).getIpv6ExtHeader() : null;
}
@Override
- protected boolean getHasMask(final Match match) {
- return ((Ipv6Match) match.getLayer3Match()).getIpv6ExtHeader().getIpv6ExthdrMask() != null;
+ protected Uint16 extractEntryMask(final Ipv6ExtHeader entry) {
+ return entry.getIpv6ExthdrMask();
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV6_EXTHDR;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected void serializeEntry(final Ipv6ExtHeader entry, final Uint16 mask, final ByteBuf outBuffer) {
+ outBuffer.writeShort(entry.getIpv6Exthdr().shortValue());
+ if (mask != null) {
+ writeMask(ByteUtil.unsignedShortToBytes(mask), outBuffer, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
+ }
}
}
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6FlowLabel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ipv6.match.fields.Ipv6Label;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
-public class Ipv6LabelEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- final Ipv6Label ipv6Label = ((Ipv6Match) match.getLayer3Match()).getIpv6Label();
- outBuffer.writeInt(ipv6Label.getIpv6Flabel().getValue().intValue());
-
- if (getHasMask(match)) {
- writeMask(ByteUtil.unsignedIntToBytes(
- ipv6Label.getFlabelMask().getValue()),
- outBuffer,
- getValueLength());
- }
+public class Ipv6LabelEntrySerializer extends AbstractMatchEntrySerializer<Ipv6Label, Ipv6FlowLabel> {
+ public Ipv6LabelEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_FLABEL,
+ EncodeConstants.SIZE_OF_INT_IN_BYTES);
}
@Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof Ipv6Match
- && ((Ipv6Match) match.getLayer3Match()).getIpv6Label() != null;
+ protected Ipv6Label extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof Ipv6Match ? ((Ipv6Match) l3Match).getIpv6Label() : null;
}
@Override
- protected boolean getHasMask(Match match) {
- return ((Ipv6Match) match.getLayer3Match()).getIpv6Label().getFlabelMask() != null;
+ protected Ipv6FlowLabel extractEntryMask(final Ipv6Label entry) {
+ return entry.getFlabelMask();
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV6_FLABEL;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ protected void serializeEntry(final Ipv6Label entry, final Ipv6FlowLabel mask, final ByteBuf outBuffer) {
+ outBuffer.writeInt(entry.getIpv6Flabel().getValue().intValue());
+ if (mask != null) {
+ writeMask(ByteUtil.unsignedIntToBytes(mask.getValue()), outBuffer, EncodeConstants.SIZE_OF_INT_IN_BYTES);
+ }
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
-public class Ipv6NdSllEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- writeMacAddress(((Ipv6Match) match.getLayer3Match()).getIpv6NdSll(), outBuffer);
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof Ipv6Match
- && ((Ipv6Match) match.getLayer3Match()).getIpv6NdSll() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV6_ND_SLL;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class Ipv6NdSllEntrySerializer extends AbstractMacAddressEntrySerializer {
+ public Ipv6NdSllEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_ND_SLL);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.MAC_ADDRESS_LENGTH;
+ protected MacAddress extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof Ipv6Match ? ((Ipv6Match) l3Match).getIpv6NdSll() : null;
}
}
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
-public class Ipv6NdTargetEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- writeIpv6Address(((Ipv6Match) match.getLayer3Match()).getIpv6NdTarget(), outBuffer);
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof Ipv6Match
- && ((Ipv6Match) match.getLayer3Match()).getIpv6NdTarget() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV6_ND_TARGET;
+public class Ipv6NdTargetEntrySerializer extends AbstractPrimitiveEntrySerializer<Ipv6Address> {
+ public Ipv6NdTargetEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_ND_TARGET,
+ EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES);
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ protected Ipv6Address extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof Ipv6Match ? ((Ipv6Match) l3Match).getIpv6NdTarget() : null;
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES;
+ protected void serializeEntry(final Ipv6Address entry, final ByteBuf outBuffer) {
+ writeIpv6Address(entry, outBuffer);
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
-public class Ipv6NdTllEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- writeMacAddress(((Ipv6Match) match.getLayer3Match()).getIpv6NdTll(), outBuffer);
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof Ipv6Match
- && ((Ipv6Match) match.getLayer3Match()).getIpv6NdTll() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV6_ND_TLL;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class Ipv6NdTllEntrySerializer extends AbstractMacAddressEntrySerializer {
+ public Ipv6NdTllEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_ND_TLL);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.MAC_ADDRESS_LENGTH;
+ protected MacAddress extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof Ipv6Match ? ((Ipv6Match) l3Match).getIpv6NdTll() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6MatchArbitraryBitMask;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.opendaylight.ipv6.arbitrary.bitmask.fields.rev160224.Ipv6ArbitraryMask;
-public class Ipv6SourceEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
-
- if (isPrefix(match)) {
- writeIpv6Prefix(((Ipv6Match) match.getLayer3Match()).getIpv6Source(), outBuffer);
- } else if (isArbitrary(match)) {
- final Ipv6MatchArbitraryBitMask ipv6 = (Ipv6MatchArbitraryBitMask) match.getLayer3Match();
- writeIpv6Address(ipv6.getIpv6SourceAddressNoMask(), outBuffer);
-
- if (getHasMask(match)) {
- writeMask(IpConversionUtil.convertIpv6ArbitraryMaskToByteArray(ipv6.getIpv6SourceArbitraryBitmask()),
- outBuffer,
- getValueLength());
- }
- }
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- if (isPrefix(match)) {
- return match.getLayer3Match() != null && ((Ipv6Match) match.getLayer3Match()).getIpv6Source() != null;
- } else if (isArbitrary(match)) {
-
- return match.getLayer3Match() != null
- && ((Ipv6MatchArbitraryBitMask) match.getLayer3Match()).getIpv6SourceAddressNoMask() != null;
- }
-
- return false;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- if (isPrefix(match)) {
- if (null != IpConversionUtil.hasIpv6Prefix(((Ipv6Match) match.getLayer3Match()).getIpv6Source())) {
- return IpConversionUtil.extractIpv6Prefix(((Ipv6Match) match.getLayer3Match()).getIpv6Source()) != null;
- }
- } else if (isArbitrary(match)) {
- return ((Ipv6MatchArbitraryBitMask) match.getLayer3Match()).getIpv6SourceArbitraryBitmask() != null;
- }
-
- return false;
- }
-
- private static boolean isPrefix(Match match) {
- return match.getLayer3Match() instanceof Ipv6Match;
- }
-
- private static boolean isArbitrary(Match match) {
- return match.getLayer3Match() instanceof Ipv6MatchArbitraryBitMask;
+public class Ipv6SourceEntrySerializer extends AbstractIpv6PolymorphicEntrySerializer {
+ public Ipv6SourceEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV6_SRC);
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV6_SRC;
+ Ipv6Prefix extractNormalEntry(final Ipv6Match normalMatch) {
+ return normalMatch.getIpv6Source();
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ Ipv6Address extractArbitraryEntryAddress(final Ipv6MatchArbitraryBitMask arbitraryMatch) {
+ return arbitraryMatch.getIpv6SourceAddressNoMask();
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES;
+ Ipv6ArbitraryMask extractArbitraryEntryMask(final Ipv6MatchArbitraryBitMask arbitraryMatch) {
+ return arbitraryMatch.getIpv6SourceArbitraryBitmask();
}
}
}
// Serialize match entries
- entryRegistry.forEach((key, value) -> {
- if (value.matchTypeCheck(match)) {
- value.serialize(match, outBuffer);
- }
- });
+ entryRegistry.values().forEach(value -> value.serializeIfPresent(match, outBuffer));
// Serialize match extensions
ExtensionResolvers
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Metadata;
+import org.opendaylight.yangtools.yang.common.Uint64;
-public class MetadataEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- // TODO: writeLong() should be faster
- outBuffer.writeBytes(ByteUtil.uint64toBytes(match.getMetadata().getMetadata()));
-
- if (getHasMask(match)) {
- // TODO: writeLong() should be faster
- writeMask(ByteUtil.uint64toBytes(match.getMetadata().getMetadataMask()),
- outBuffer,
- getValueLength());
- }
+public class MetadataEntrySerializer extends AbstractMatchEntrySerializer<Metadata, Uint64> {
+ public MetadataEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.METADATA,
+ EncodeConstants.SIZE_OF_LONG_IN_BYTES);
}
@Override
- public boolean matchTypeCheck(final Match match) {
- return match.getMetadata() != null;
+ protected Metadata extractEntry(Match match) {
+ return match.getMetadata();
}
@Override
- protected boolean getHasMask(final Match match) {
- return match.getMetadata().getMetadataMask() != null;
+ protected Uint64 extractEntryMask(Metadata entry) {
+ return entry.getMetadataMask();
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.METADATA;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_LONG_IN_BYTES;
+ protected void serializeEntry(Metadata entry, Uint64 mask, ByteBuf outBuffer) {
+ outBuffer.writeBytes(ByteUtil.uint64toBytes(entry.getMetadata()));
+ if (mask != null) {
+ writeMask(ByteUtil.uint64toBytes(mask), outBuffer, EncodeConstants.SIZE_OF_LONG_IN_BYTES);
+ }
}
}
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.ProtocolMatchFields;
+import org.opendaylight.yangtools.yang.common.Uint8;
-public class MplsBosEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeBoolean(match.getProtocolMatchFields().getMplsBos().toJava() != 0);
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getProtocolMatchFields() != null && match.getProtocolMatchFields().getMplsBos() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.MPLS_BOS;
+public class MplsBosEntrySerializer extends AbstractPrimitiveEntrySerializer<Uint8> {
+ public MplsBosEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.MPLS_BOS,
+ EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+ protected Uint8 extractEntry(final Match match) {
+ final ProtocolMatchFields protoFields = match.getProtocolMatchFields();
+ return protoFields == null ? null : protoFields.getMplsBos();
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
+ protected void serializeEntry(final Uint8 entry, final ByteBuf outBuffer) {
+ outBuffer.writeBoolean(entry.byteValue() != 0);
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.ProtocolMatchFields;
+import org.opendaylight.yangtools.yang.common.Uint32;
-public class MplsLabelEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeInt(match.getProtocolMatchFields().getMplsLabel().intValue());
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getProtocolMatchFields() != null && match.getProtocolMatchFields().getMplsLabel() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.MPLS_LABEL;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class MplsLabelEntrySerializer extends AbstractUint32EntrySerializer {
+ public MplsLabelEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.MPLS_LABEL);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ protected Uint32 extractEntry(final Match match) {
+ final ProtocolMatchFields protoFields = match.getProtocolMatchFields();
+ return protoFields == null ? null : protoFields.getMplsLabel();
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.ProtocolMatchFields;
+import org.opendaylight.yangtools.yang.common.Uint8;
-public class MplsTcEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeByte(match.getProtocolMatchFields().getMplsTc().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getProtocolMatchFields() != null && match.getProtocolMatchFields().getMplsTc() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.MPLS_TC;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class MplsTcEntrySerializer extends AbstractUint8EntrySerializer {
+ public MplsTcEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.MPLS_TC);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
+ protected Uint8 extractEntry(final Match match) {
+ final ProtocolMatchFields protoFields = match.getProtocolMatchFields();
+ return protoFields == null ? null : protoFields.getMplsTc();
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.PacketTypeMatch;
+import org.opendaylight.yangtools.yang.common.Uint32;
-public class PacketTypeEntrySerializer extends AbstractMatchEntrySerializer {
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeInt(match.getPacketTypeMatch().getPacketType().intValue());
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.PACKET_TYPE;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+public class PacketTypeEntrySerializer extends AbstractUint32EntrySerializer {
+ public PacketTypeEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.PACKET_TYPE);
}
@Override
- public boolean matchTypeCheck(Match match) {
- return match.getPacketTypeMatch() != null && match.getPacketTypeMatch().getPacketType() != null;
+ protected Uint32 extractEntry(final Match match) {
+ final PacketTypeMatch typeMatch = match.getPacketTypeMatch();
+ return typeMatch == null ? null : typeMatch.getPacketType();
}
}
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.ProtocolMatchFields;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.protocol.match.fields.Pbb;
+import org.opendaylight.yangtools.yang.common.Uint32;
-public class PbbEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeMedium(match.getProtocolMatchFields().getPbb().getPbbIsid().intValue());
-
- if (getHasMask(match)) {
- writeMask(ByteUtil.unsignedMediumToBytes(
- match.getProtocolMatchFields().getPbb().getPbbMask()),
- outBuffer,
- getValueLength());
- }
+public class PbbEntrySerializer extends AbstractMatchEntrySerializer<Pbb, Uint32> {
+ public PbbEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.PBB_ISID, EncodeConstants.SIZE_OF_3_BYTES);
}
@Override
- public boolean matchTypeCheck(Match match) {
- return match.getProtocolMatchFields() != null && match.getProtocolMatchFields().getPbb() != null;
+ protected Pbb extractEntry(Match match) {
+ final ProtocolMatchFields protoFields = match.getProtocolMatchFields();
+ return protoFields == null ? null : protoFields.getPbb();
}
@Override
- protected boolean getHasMask(Match match) {
- return match.getProtocolMatchFields().getPbb().getPbbMask() != null;
+ protected Uint32 extractEntryMask(Pbb entry) {
+ return entry.getPbbMask();
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.PBB_ISID;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_3_BYTES;
+ protected void serializeEntry(Pbb entry, Uint32 mask, ByteBuf outBuffer) {
+ outBuffer.writeMedium(entry.getPbbIsid().intValue());
+ if (mask != null) {
+ writeMask(ByteUtil.unsignedMediumToBytes(mask), outBuffer, EncodeConstants.SIZE_OF_3_BYTES);
+ }
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.SctpMatch;
-public class SctpDestinationPortEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(((SctpMatch) match.getLayer4Match()).getSctpDestinationPort().getValue().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getLayer4Match() != null
- && match.getLayer4Match() instanceof SctpMatch
- && ((SctpMatch) match.getLayer4Match()).getSctpDestinationPort() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.SCTP_DST;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class SctpDestinationPortEntrySerializer extends AbstractPortNumberEntrySerializer {
+ public SctpDestinationPortEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.SCTP_DST);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected PortNumber extractPort(final Match match) {
+ final Layer4Match l4match = match.getLayer4Match();
+ return l4match instanceof SctpMatch ? ((SctpMatch) l4match).getSctpDestinationPort() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.SctpMatch;
-public class SctpSourcePortEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(((SctpMatch) match.getLayer4Match()).getSctpSourcePort().getValue().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getLayer4Match() != null
- && match.getLayer4Match() instanceof SctpMatch
- && ((SctpMatch) match.getLayer4Match()).getSctpSourcePort() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.SCTP_SRC;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class SctpSourcePortEntrySerializer extends AbstractPortNumberEntrySerializer {
+ public SctpSourcePortEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.SCTP_SRC);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected PortNumber extractPort(final Match match) {
+ final Layer4Match l4match = match.getLayer4Match();
+ return l4match instanceof SctpMatch ? ((SctpMatch) l4match).getSctpSourcePort() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatch;
-public class TcpDestinationPortEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(((TcpMatch) match.getLayer4Match()).getTcpDestinationPort().getValue().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getLayer4Match() != null
- && match.getLayer4Match() instanceof TcpMatch
- && ((TcpMatch) match.getLayer4Match()).getTcpDestinationPort() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.TCP_DST;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class TcpDestinationPortEntrySerializer extends AbstractPortNumberEntrySerializer {
+ public TcpDestinationPortEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.TCP_DST);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected PortNumber extractPort(final Match match) {
+ final Layer4Match l4match = match.getLayer4Match();
+ return l4match instanceof TcpMatch ? ((TcpMatch) l4match).getTcpDestinationPort() : null;
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
-import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.TcpFlagsMatch;
+import org.opendaylight.yangtools.yang.common.Uint16;
-public class TcpFlagsEntrySerializer extends AbstractExperimenterMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(match.getTcpFlagsMatch().getTcpFlags().toJava());
-
- if (getHasMask(match)) {
- writeMask(ByteUtil.unsignedShortToBytes(
- match.getTcpFlagsMatch().getTcpFlagsMask()),
- outBuffer,
- getValueLength());
- }
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getTcpFlagsMatch() != null && match.getTcpFlagsMatch().getTcpFlags() != null;
+public class TcpFlagsEntrySerializer extends AbstractExperimenterMatchEntrySerializer<TcpFlagsMatch, Uint16> {
+ public TcpFlagsEntrySerializer() {
+ super(EncodeConstants.ONFOXM_ET_TCP_FLAGS, EncodeConstants.SIZE_OF_SHORT_IN_BYTES,
+ EncodeConstants.ONF_EXPERIMENTER_ID.toJava());
}
@Override
- protected boolean getHasMask(final Match match) {
- return match.getTcpFlagsMatch().getTcpFlagsMask() != null;
+ protected TcpFlagsMatch extractEntry(Match match) {
+ final TcpFlagsMatch flagsMatch = match.getTcpFlagsMatch();
+ return flagsMatch == null || flagsMatch.getTcpFlags() == null ? null : flagsMatch;
}
@Override
- protected long getExperimenterId() {
- return EncodeConstants.ONF_EXPERIMENTER_ID.toJava();
+ protected Uint16 extractEntryMask(TcpFlagsMatch entry) {
+ return entry.getTcpFlagsMask();
}
@Override
- protected int getOxmFieldCode() {
- return EncodeConstants.ONFOXM_ET_TCP_FLAGS;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.EXPERIMENTER_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected void serializeEntryContent(TcpFlagsMatch entry, Uint16 mask, ByteBuf outBuffer) {
+ outBuffer.writeShort(entry.getTcpFlags().shortValue());
+ if (mask != null) {
+ writeMask(ByteUtil.unsignedShortToBytes(mask), outBuffer, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
+ }
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatch;
-public class TcpSourcePortEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(((TcpMatch) match.getLayer4Match()).getTcpSourcePort().getValue().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getLayer4Match() != null
- && match.getLayer4Match() instanceof TcpMatch
- && ((TcpMatch) match.getLayer4Match()).getTcpSourcePort() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.TCP_SRC;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class TcpSourcePortEntrySerializer extends AbstractPortNumberEntrySerializer {
+ public TcpSourcePortEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.TCP_SRC);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected PortNumber extractPort(final Match match) {
+ final Layer4Match l4match = match.getLayer4Match();
+ return l4match instanceof TcpMatch ? ((TcpMatch) l4match).getTcpSourcePort() : null;
}
}
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Tunnel;
+import org.opendaylight.yangtools.yang.common.Uint64;
-public class TunnelIdEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- // TODO: writeLong() should be faster
- outBuffer.writeBytes(ByteUtil.uint64toBytes(match.getTunnel().getTunnelId()));
- if (getHasMask(match)) {
- writeMask(ByteUtil.uint64toBytes(match.getTunnel().getTunnelMask()), outBuffer, getValueLength());
- }
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getTunnel() != null && match.getTunnel().getTunnelId() != null;
+public class TunnelIdEntrySerializer extends AbstractMatchEntrySerializer<Tunnel, Uint64> {
+ public TunnelIdEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.TUNNEL_ID,
+ EncodeConstants.SIZE_OF_LONG_IN_BYTES);
}
@Override
- protected boolean getHasMask(final Match match) {
- return match.getTunnel().getTunnelMask() != null;
+ protected Tunnel extractEntry(Match match) {
+ final Tunnel tunnel = match.getTunnel();
+ return tunnel == null || tunnel.getTunnelId() == null ? null : tunnel;
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.TUNNEL_ID;
+ protected Uint64 extractEntryMask(Tunnel entry) {
+ return entry.getTunnelMask();
}
@Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_LONG_IN_BYTES;
+ protected void serializeEntry(Tunnel entry, Uint64 mask, ByteBuf outBuffer) {
+ outBuffer.writeBytes(ByteUtil.uint64toBytes(entry.getTunnelId()));
+ if (mask != null) {
+ writeMask(ByteUtil.uint64toBytes(mask), outBuffer, EncodeConstants.SIZE_OF_LONG_IN_BYTES);
+ }
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.TunnelIpv4Match;
-public class TunnelIpv4DestinationEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- // TODO: Why is this serialization exactly same as in Ipv4DestinationEntrySerializer?
- writeIpv4Prefix(((TunnelIpv4Match) match.getLayer3Match()).getTunnelIpv4Destination(), outBuffer);
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof TunnelIpv4Match
- && ((TunnelIpv4Match) match.getLayer3Match()).getTunnelIpv4Destination() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return IpConversionUtil.hasIpv4Prefix(((TunnelIpv4Match) match.getLayer3Match()).getTunnelIpv4Destination())
- != null;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV4_DST;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+// TODO: Why is this serialization exactly same as in Ipv4DestinationEntrySerializer?
+public class TunnelIpv4DestinationEntrySerializer extends AbstractIpv4PrefixEntrySerializer {
+ public TunnelIpv4DestinationEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV4_DST);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ protected Ipv4Prefix extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof TunnelIpv4Match ? ((TunnelIpv4Match) l3Match).getTunnelIpv4Destination() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
-import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common.IpConversionUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.TunnelIpv4Match;
-public class TunnelIpv4SourceEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(Match match, ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- // TODO: Why is this serialization exactly same as in Ipv4SourceEntrySerializer?
- writeIpv4Prefix(((TunnelIpv4Match) match.getLayer3Match()).getTunnelIpv4Source(), outBuffer);
- }
-
- @Override
- public boolean matchTypeCheck(Match match) {
- return match.getLayer3Match() != null
- && match.getLayer3Match() instanceof TunnelIpv4Match
- && ((TunnelIpv4Match) match.getLayer3Match()).getTunnelIpv4Source() != null;
- }
-
- @Override
- protected boolean getHasMask(Match match) {
- return IpConversionUtil.hasIpv4Prefix(((TunnelIpv4Match) match.getLayer3Match()).getTunnelIpv4Source()) != null;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.IPV4_SRC;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+// TODO: Why is this serialization exactly same as in Ipv4SourceEntrySerializer?
+public class TunnelIpv4SourceEntrySerializer extends AbstractIpv4PrefixEntrySerializer {
+ public TunnelIpv4SourceEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.IPV4_SRC);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_INT_IN_BYTES;
+ protected Ipv4Prefix extractEntry(final Match match) {
+ final Layer3Match l3Match = match.getLayer3Match();
+ return l3Match instanceof TunnelIpv4Match ? ((TunnelIpv4Match) l3Match).getTunnelIpv4Source() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatch;
-public class UdpDestinationPortEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(((UdpMatch) match.getLayer4Match()).getUdpDestinationPort().getValue().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getLayer4Match() != null
- && match.getLayer4Match() instanceof UdpMatch
- && ((UdpMatch) match.getLayer4Match()).getUdpDestinationPort() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.UDP_DST;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class UdpDestinationPortEntrySerializer extends AbstractPortNumberEntrySerializer {
+ public UdpDestinationPortEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.UDP_DST);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected PortNumber extractPort(final Match match) {
+ final Layer4Match l4match = match.getLayer4Match();
+ return l4match instanceof UdpMatch ? ((UdpMatch) l4match).getUdpDestinationPort() : null;
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
-import io.netty.buffer.ByteBuf;
-import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatch;
-public class UdpSourcePortEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeShort(((UdpMatch) match.getLayer4Match()).getUdpSourcePort().getValue().toJava());
- }
-
- @Override
- public boolean matchTypeCheck(final Match match) {
- return match.getLayer4Match() != null
- && match.getLayer4Match() instanceof UdpMatch
- && ((UdpMatch) match.getLayer4Match()).getUdpSourcePort() != null;
- }
-
- @Override
- protected boolean getHasMask(final Match match) {
- return false;
- }
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.UDP_SRC;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
+public class UdpSourcePortEntrySerializer extends AbstractPortNumberEntrySerializer {
+ public UdpSourcePortEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.UDP_SRC);
}
@Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ protected PortNumber extractPort(final Match match) {
+ final Layer4Match l4match = match.getLayer4Match();
+ return l4match instanceof UdpMatch ? ((UdpMatch) l4match).getUdpSourcePort() : null;
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.match;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanPcp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.VlanMatch;
-public class VlanPcpEntrySerializer extends AbstractMatchEntrySerializer {
-
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- outBuffer.writeByte(match.getVlanMatch().getVlanPcp().getValue().toJava());
+public class VlanPcpEntrySerializer extends AbstractPrimitiveEntrySerializer<VlanPcp> {
+ public VlanPcpEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.VLAN_PCP,
+ EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
}
@Override
- public boolean matchTypeCheck(final Match match) {
- return match.getVlanMatch() != null && match.getVlanMatch().getVlanPcp() != null;
+ protected VlanPcp extractEntry(final Match match) {
+ final VlanMatch vlanMatch = match.getVlanMatch();
+ return vlanMatch == null ? null : vlanMatch.getVlanPcp();
}
@Override
- protected boolean getHasMask(final Match match) {
- return false;
+ protected void serializeEntry(final VlanPcp entry, final ByteBuf outBuffer) {
+ outBuffer.writeByte(entry.getValue().byteValue());
}
-
- @Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.VLAN_PCP;
- }
-
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
-
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
- }
-
}
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.api.util.OxmMatchConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.VlanMatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanId;
+import org.opendaylight.yangtools.yang.common.Empty;
-public class VlanVidEntrySerializer extends AbstractMatchEntrySerializer {
+public class VlanVidEntrySerializer extends AbstractMatchEntrySerializer<VlanId, Empty> {
private static final byte[] VLAN_VID_MASK = new byte[]{16, 0};
- @Override
- public void serialize(final Match match, final ByteBuf outBuffer) {
- super.serialize(match, outBuffer);
- final org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId vlanId =
- match.getVlanMatch().getVlanId().getVlanId();
-
- int vlanVidValue = vlanId != null ? vlanId.getValue().toJava() : 0;
-
- if (Boolean.TRUE.equals(match.getVlanMatch().getVlanId().isVlanIdPresent())) {
- short cfi = 1 << 12;
- vlanVidValue = vlanVidValue | cfi;
- }
-
- outBuffer.writeShort(vlanVidValue);
-
- if (getHasMask(match)) {
- writeMask(VLAN_VID_MASK, outBuffer, getValueLength());
- }
+ public VlanVidEntrySerializer() {
+ super(OxmMatchConstants.OPENFLOW_BASIC_CLASS, OxmMatchConstants.VLAN_VID,
+ EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
}
@Override
- public boolean matchTypeCheck(final Match match) {
- return match.getVlanMatch() != null && match.getVlanMatch().getVlanId() != null;
+ protected VlanId extractEntry(Match match) {
+ final VlanMatch vlanMatch = match.getVlanMatch();
+ return vlanMatch == null ? null : vlanMatch.getVlanId();
}
@Override
- protected boolean getHasMask(final Match match) {
- final VlanId vlanId = match.getVlanMatch().getVlanId();
- return Boolean.TRUE.equals(vlanId.isVlanIdPresent())
- && (vlanId.getVlanId() == null || vlanId.getVlanId().getValue().toJava() == 0);
+ protected Empty extractEntryMask(VlanId entry) {
+ return Boolean.TRUE.equals(entry.isVlanIdPresent())
+ && (entry.getVlanId() == null || entry.getVlanId().getValue().shortValue() == 0) ? Empty.getInstance()
+ : null;
}
@Override
- protected int getOxmFieldCode() {
- return OxmMatchConstants.VLAN_VID;
- }
+ protected void serializeEntry(VlanId entry, Empty mask, ByteBuf outBuffer) {
+ final org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId vlanId = entry.getVlanId();
- @Override
- protected int getOxmClassCode() {
- return OxmMatchConstants.OPENFLOW_BASIC_CLASS;
- }
+ int vlanVidValue = vlanId != null ? vlanId.getValue().toJava() : 0;
- @Override
- protected int getValueLength() {
- return EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
+ if (Boolean.TRUE.equals(entry.isVlanIdPresent())) {
+ short cfi = 1 << 12;
+ vlanVidValue = vlanVidValue | cfi;
+ }
+ outBuffer.writeShort(vlanVidValue);
+
+ if (mask != null) {
+ writeMask(VLAN_VID_MASK, outBuffer, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
+ }
}
}
final DottedQuad[] quads = new DottedQuad[IPV4_ADDRESS_LENGTH + 1];
for (int i = 0; i <= IPV4_ADDRESS_LENGTH; ++i) {
- final int maskBits = (int) (0xffffffffL << IPV4_ADDRESS_LENGTH - i);
+ final int maskBits = maskForIpv4Prefix(i);
quads[i] = new DottedQuad(new StringBuilder(15)
.append(maskBits >>> 24).append('.')
.append(maskBits >>> 16 & 0xff).append('.')
return prefix != null && prefix < addressLength ? prefix : null;
}
+ public static int maskForIpv4Prefix(final int prefixLength) {
+ return (int) (0xffffffffL << IPV4_ADDRESS_LENGTH - prefixLength);
+ }
+
/*
* BIG FAT WARNING!!!
* Read all of the following before you touch any v6 code or decide to
Code Review / openflowplugin.git / commitdiff