import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.BarrierOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
connectionContext.handshakeSuccessful();
// fire barrier in order to sweep all handshake and posthandshake messages before continue
- final ListenableFuture<RpcResult<BarrierOutput>> barrier = fireBarrier(version, 0L);
+ final ListenableFuture<RpcResult<BarrierOutput>> barrier = fireBarrier(version, Uint32.ZERO);
Futures.addCallback(barrier, addBarrierCallback(), MoreExecutors.directExecutor());
}
};
}
- private ListenableFuture<RpcResult<BarrierOutput>> fireBarrier(final Short version, final long xid) {
+ private ListenableFuture<RpcResult<BarrierOutput>> fireBarrier(final Short version, final Uint32 xid) {
final BarrierInput barrierInput = new BarrierInputBuilder()
.setXid(xid)
.setVersion(version)
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCaseBuilder;
public class GroupActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
return new GroupActionCaseBuilder()
.setGroupAction(new GroupActionBuilder()
- .setGroupId(message.readUnsignedInt())
+ .setGroupId(readUint32(message))
.build())
.build();
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new GroupActionCaseBuilder().build();
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputActionBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
public class OutputActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
final Uri portUri = OpenflowPortsUtil
.getProtocolAgnosticPortUri(EncodeConstants.OF13_VERSION_ID, message.readUnsignedInt());
- final int maxLength = message.readUnsignedShort();
+ final Uint16 maxLength = readUint16(message);
message.skipBytes(ActionConstants.OUTPUT_PADDING);
return new OutputActionCaseBuilder()
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new OutputActionCaseBuilder().build();
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsActionBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
public class PopMplsActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
- final int ethType = message.readUnsignedShort();
+ final Uint16 ethType = readUint16(message);
message.skipBytes(ActionConstants.ETHERTYPE_ACTION_PADDING);
return new PopMplsActionCaseBuilder()
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new PopMplsActionCaseBuilder().build();
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushMplsActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.mpls.action._case.PushMplsActionBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
public class PushMplsActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
- final int ethType = message.readUnsignedShort();
+ final Uint16 ethType = readUint16(message);
message.skipBytes(ActionConstants.ETHERTYPE_ACTION_PADDING);
return new PushMplsActionCaseBuilder()
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new PushMplsActionCaseBuilder().build();
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushPbbActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.pbb.action._case.PushPbbActionBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
public class PushPbbActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
- final int ethType = message.readUnsignedShort();
+ final Uint16 ethType = readUint16(message);
message.skipBytes(ActionConstants.ETHERTYPE_ACTION_PADDING);
return new PushPbbActionCaseBuilder()
- .setPushPbbAction(new PushPbbActionBuilder()
- .setEthernetType(ethType)
- .build())
+ .setPushPbbAction(new PushPbbActionBuilder().setEthernetType(ethType).build())
.build();
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new PushPbbActionCaseBuilder().build();
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushVlanActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.vlan.action._case.PushVlanActionBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
public class PushVlanActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
- final int ethType = message.readUnsignedShort();
+ final Uint16 ethType = readUint16(message);
message.skipBytes(ActionConstants.ETHERTYPE_ACTION_PADDING);
return new PushVlanActionCaseBuilder()
- .setPushVlanAction(new PushVlanActionBuilder()
- .setEthernetType(ethType)
- .build())
+ .setPushVlanAction(new PushVlanActionBuilder().setEthernetType(ethType).build())
.build();
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new PushVlanActionCaseBuilder().build();
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetMplsTtlActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.mpls.ttl.action._case.SetMplsTtlActionBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class SetMplsTtlActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
- final short mplsTtl = message.readUnsignedByte();
+ final Uint8 mplsTtl = readUint8(message);
message.skipBytes(ActionConstants.SET_MPLS_TTL_PADDING);
return new SetMplsTtlActionCaseBuilder()
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new SetMplsTtlActionCaseBuilder().build();
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwTtlActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.ttl.action._case.SetNwTtlActionBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class SetNwTtlActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
- final short nwTtl = message.readUnsignedByte();
+ final Uint8 nwTtl = readUint8(message);
message.skipBytes(ActionConstants.SET_NW_TTL_PADDING);
return new SetNwTtlActionCaseBuilder()
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new SetNwTtlActionCaseBuilder().build();
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetQueueActionCaseBuilder;
public class SetQueueActionDeserializer extends AbstractActionDeserializer {
@Override
- public Action deserialize(ByteBuf message) {
+ public Action deserialize(final ByteBuf message) {
processHeader(message);
- final long queueId = message.readUnsignedInt();
return new SetQueueActionCaseBuilder()
.setSetQueueAction(new SetQueueActionBuilder()
- .setQueueId(queueId)
+ .setQueueId(readUint32(message))
.build())
.build();
}
@Override
- public Action deserializeHeader(ByteBuf message) {
+ public Action deserializeHeader(final ByteBuf message) {
processHeader(message);
return new SetQueueActionCaseBuilder().build();
}
-
}
package org.opendaylight.openflowplugin.impl.protocol.deserialization.instruction;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.GoToTableCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.go.to.table._case.GoToTableBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class GoToTableInstructionDeserializer extends AbstractInstructionDeserializer {
@Override
- public Instruction deserialize(ByteBuf message) {
+ public Instruction deserialize(final ByteBuf message) {
processHeader(message);
- final short tableId = message.readUnsignedByte();
+ final Uint8 tableId = readUint8(message);
message.skipBytes(InstructionConstants.PADDING_IN_GOTO_TABLE);
return new GoToTableCaseBuilder()
}
@Override
- public Instruction deserializeHeader(ByteBuf message) {
+ public Instruction deserializeHeader(final ByteBuf message) {
processHeader(message);
return new GoToTableCaseBuilder().build();
}
* 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.deserialization.instruction;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.MeterCaseBuilder;
public class MeterInstructionDeserializer extends AbstractInstructionDeserializer {
@Override
- public Instruction deserialize(ByteBuf message) {
+ public Instruction deserialize(final ByteBuf message) {
processHeader(message);
return new MeterCaseBuilder()
.setMeter(new MeterBuilder()
- .setMeterId(new MeterId(message.readUnsignedInt()))
+ .setMeterId(new MeterId(readUint32(message)))
.build())
.build();
}
@Override
- public Instruction deserializeHeader(ByteBuf message) {
+ public Instruction deserializeHeader(final ByteBuf message) {
processHeader(message);
return new MeterCaseBuilder().build();
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.instruction;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCaseBuilder;
public class WriteMetadataInstructionDeserializer extends AbstractInstructionDeserializer {
@Override
- public Instruction deserialize(ByteBuf message) {
+ public Instruction deserialize(final ByteBuf message) {
processHeader(message);
message.skipBytes(InstructionConstants.PADDING_IN_WRITE_METADATA);
- final byte[] meta = new byte[Long.BYTES];
- message.readBytes(meta);
- final byte[] metaMask = new byte[Long.BYTES];
- message.readBytes(metaMask);
-
return new WriteMetadataCaseBuilder()
.setWriteMetadata(new WriteMetadataBuilder()
- .setMetadata(new BigInteger(1, meta))
- .setMetadataMask(new BigInteger(1, metaMask))
+ .setMetadata(readUint64(message))
+ .setMetadataMask(readUint64(message))
.build())
.build();
}
@Override
- public Instruction deserializeHeader(ByteBuf message) {
+ public Instruction deserializeHeader(final ByteBuf message) {
processHeader(message);
return new WriteMetadataCaseBuilder().build();
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
+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.ethernet.match.fields.EthernetTypeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatchBuilder;
public class EthernetTypeEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final int type = message.readUnsignedShort();
+ final EthernetType etherType = new EthernetTypeBuilder()
+ .setType(new EtherType(readUint16(message).toUint32()))
+ .build();
if (builder.getEthernetMatch() == null) {
- builder.setEthernetMatch(new EthernetMatchBuilder()
- .setEthernetType(new EthernetTypeBuilder()
- .setType(new EtherType(Long.valueOf(type)))
- .build())
- .build());
+ builder.setEthernetMatch(new EthernetMatchBuilder().setEthernetType(etherType).build());
} else if (builder.getEthernetMatch().getEthernetType() == null) {
builder.setEthernetMatch(new EthernetMatchBuilder(builder.getEthernetMatch())
- .setEthernetType(new EthernetTypeBuilder()
- .setType(new EtherType(Long.valueOf(type)))
- .build())
+ .setEthernetType(etherType)
.build());
} else {
throwErrorOnMalformed(builder, "ethernetMatch", "ethernetType");
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv4MatchBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class Icmpv4CodeEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short code = message.readUnsignedByte();
+ final Uint8 code = readUint8(message);
if (builder.getIcmpv4Match() == null) {
builder.setIcmpv4Match(new Icmpv4MatchBuilder()
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv4MatchBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class Icmpv4TypeEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short type = message.readUnsignedByte();
+ final Uint8 type = readUint8(message);
if (builder.getIcmpv4Match() == null) {
builder.setIcmpv4Match(new Icmpv4MatchBuilder()
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv6MatchBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class Icmpv6CodeEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short code = message.readUnsignedByte();
+ final Uint8 code = readUint8(message);
if (builder.getIcmpv6Match() == null) {
builder.setIcmpv6Match(new Icmpv6MatchBuilder()
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Icmpv6MatchBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class Icmpv6TypeEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short type = message.readUnsignedByte();
+ final Uint8 type = readUint8(message);
if (builder.getIcmpv6Match() == null) {
builder.setIcmpv6Match(new Icmpv6MatchBuilder()
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
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.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatchBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class IpDscpEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short dscp = message.readUnsignedByte();
+ final Uint8 dscp = readUint8(message);
if (builder.getIpMatch() == null) {
builder.setIpMatch(new IpMatchBuilder()
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatchBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class IpEcnEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short ecn = message.readUnsignedByte();
+ final Uint8 ecn = readUint8(message);
if (builder.getIpMatch() == null) {
builder.setIpMatch(new IpMatchBuilder()
* 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.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatchBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class IpProtoEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short proto = message.readUnsignedByte();
+ final Uint8 proto = readUint8(message);
if (builder.getIpMatch() == null) {
builder.setIpMatch(new IpMatchBuilder()
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.deserialization.match.OxmDeserializerHelper;
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
public class Ipv6ExtHeaderEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
final boolean hasMask = processHeader(message);
final Ipv6ExtHeaderBuilder extHeaderBuilder = new Ipv6ExtHeaderBuilder()
- .setIpv6Exthdr(message.readUnsignedShort());
+ .setIpv6Exthdr(readUint16(message));
if (hasMask) {
final byte[] mask = OxmDeserializerHelper.convertMask(message, Short.BYTES);
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.deserialization.match.OxmDeserializerHelper;
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
public class Ipv6FlabelEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
final boolean hasMask = processHeader(message);
final Ipv6LabelBuilder ipv6labelBuilder = new Ipv6LabelBuilder()
- .setIpv6Flabel(new Ipv6FlowLabel(message.readUnsignedInt()));
+ .setIpv6Flabel(new Ipv6FlowLabel(readUint32(message)));
if (hasMask) {
final byte[] mask = OxmDeserializerHelper.convertMask(message, Integer.BYTES);
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Metadata;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.MetadataBuilder;
public class MetadataEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
final boolean hasMask = processHeader(message);
- final Metadata metadata = builder.getMetadata();
- final byte[] metaByte = new byte[Long.BYTES];
- message.readBytes(metaByte);
final MetadataBuilder metadataBuilder = new MetadataBuilder()
- .setMetadata(new BigInteger(1, metaByte));
+ .setMetadata(readUint64(message));
if (hasMask) {
- final byte[] metaMask = new byte[Long.BYTES];
- message.readBytes(metaMask);
- metadataBuilder.setMetadataMask(new BigInteger(1, metaMask));
+ metadataBuilder.setMetadataMask(readUint64(message));
}
+ final Metadata metadata = builder.getMetadata();
if (metadata == null) {
builder.setMetadata(metadataBuilder.build());
} else {
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.ProtocolMatchFieldsBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class MplsBosEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short mplsBos = message.readUnsignedByte();
+ final Uint8 mplsBos = readUint8(message);
if (builder.getProtocolMatchFields() == null) {
builder.setProtocolMatchFields(new ProtocolMatchFieldsBuilder()
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.ProtocolMatchFieldsBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class MplsLabelEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final long mplsLabel = message.readUnsignedInt();
+ final Uint32 mplsLabel = readUint32(message);
if (builder.getProtocolMatchFields() == null) {
builder.setProtocolMatchFields(new ProtocolMatchFieldsBuilder()
throwErrorOnMalformed(builder, "protocolMatchFields", "mplsLabel");
}
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.ProtocolMatchFieldsBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class MplsTcEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short mplsTc = message.readUnsignedByte();
+ final Uint8 mplsTc = readUint8(message);
if (builder.getProtocolMatchFields() == null) {
builder.setProtocolMatchFields(new ProtocolMatchFieldsBuilder()
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.PacketTypeMatchBuilder;
public class PacketTypeEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
if (builder.getPacketTypeMatch() != null) {
throwErrorOnMalformed(builder, "packet-type");
}
processHeader(message);
- final long packetType = message.readUnsignedInt();
- builder.setPacketTypeMatch(new PacketTypeMatchBuilder().setPacketType(packetType).build());
+ builder.setPacketTypeMatch(new PacketTypeMatchBuilder().setPacketType(readUint32(message)).build());
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
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.flow.types.rev131026.flow.MatchBuilder;
public class SctpDestinationPortEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final int port = message.readUnsignedShort();
+ final PortNumber port = new PortNumber(readUint16(message));
if (builder.getLayer4Match() == null) {
- builder.setLayer4Match(new SctpMatchBuilder()
- .setSctpDestinationPort(new PortNumber(port))
- .build());
+ builder.setLayer4Match(new SctpMatchBuilder().setSctpDestinationPort(port).build());
} else if (builder.getLayer4Match() instanceof SctpMatch
&& ((SctpMatch) builder.getLayer4Match()).getSctpDestinationPort() == null) {
builder.setLayer4Match(new SctpMatchBuilder((SctpMatch) builder.getLayer4Match())
- .setSctpDestinationPort(new PortNumber(port))
+ .setSctpDestinationPort(port)
.build());
} else {
throwErrorOnMalformed(builder, "layer4Match", "sctpDestinationPort");
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
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.flow.types.rev131026.flow.MatchBuilder;
public class SctpSourcePortEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final int port = message.readUnsignedShort();
+ final PortNumber port = new PortNumber(readUint16(message));
if (builder.getLayer4Match() == null) {
- builder.setLayer4Match(new SctpMatchBuilder()
- .setSctpSourcePort(new PortNumber(port))
- .build());
+ builder.setLayer4Match(new SctpMatchBuilder().setSctpSourcePort(port).build());
} else if (builder.getLayer4Match() instanceof SctpMatch
&& ((SctpMatch) builder.getLayer4Match()).getSctpSourcePort() == null) {
builder.setLayer4Match(new SctpMatchBuilder((SctpMatch) builder.getLayer4Match())
- .setSctpSourcePort(new PortNumber(port))
+ .setSctpSourcePort(port)
.build());
} else {
throwErrorOnMalformed(builder, "layer4Match", "sctpSourcePort");
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
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.flow.types.rev131026.flow.MatchBuilder;
public class TcpDestinationPortEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
boolean hasMask = processHeader(message);
- final int port = message.readUnsignedShort();
- final int portMask = hasMask ? message.readUnsignedShort() : 0;
+ final PortNumber port = new PortNumber(readUint16(message));
if (builder.getLayer4Match() == null) {
TcpMatchBuilder tcpMatchBuilder = new TcpMatchBuilder()
- .setTcpDestinationPort(new PortNumber(port));
+ .setTcpDestinationPort(port);
if (hasMask) {
- tcpMatchBuilder.setTcpDestinationPortMask(new PortNumber(portMask));
+ tcpMatchBuilder.setTcpDestinationPortMask(new PortNumber(readUint16(message)));
}
builder.setLayer4Match(tcpMatchBuilder.build());
} else if (builder.getLayer4Match() instanceof TcpMatch
&& ((TcpMatch) builder.getLayer4Match()).getTcpDestinationPort() == null) {
TcpMatchBuilder tcpMatchBuilder = new TcpMatchBuilder((TcpMatch) builder.getLayer4Match())
- .setTcpDestinationPort(new PortNumber(port));
+ .setTcpDestinationPort(port);
if (hasMask) {
- tcpMatchBuilder.setTcpDestinationPortMask(new PortNumber(portMask));
+ tcpMatchBuilder.setTcpDestinationPortMask(new PortNumber(readUint16(message)));
}
builder.setLayer4Match(tcpMatchBuilder.build());
} else {
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.TcpFlagsMatchBuilder;
public class TcpFlagsEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
final boolean hasMask = processHeader(message);
message.readUnsignedInt(); // Just skip experimenter ID for now, not used
final TcpFlagsMatchBuilder tcpFlagsBuilder = new TcpFlagsMatchBuilder()
- .setTcpFlags(message.readUnsignedShort());
+ .setTcpFlags(readUint16(message));
if (hasMask) {
- tcpFlagsBuilder.setTcpFlagsMask(message.readUnsignedShort());
+ tcpFlagsBuilder.setTcpFlagsMask(readUint16(message));
}
if (builder.getTcpFlagsMatch() == null) {
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
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.flow.types.rev131026.flow.MatchBuilder;
public class TcpSourcePortEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
boolean hasMask = processHeader(message);
- final int port = message.readUnsignedShort();
- final int portMask = hasMask ? message.readUnsignedShort() : 0;
+ final PortNumber port = new PortNumber(readUint16(message));
if (builder.getLayer4Match() == null) {
TcpMatchBuilder tcpMatchBuilder = new TcpMatchBuilder()
- .setTcpSourcePort(new PortNumber(port));
+ .setTcpSourcePort(port);
if (hasMask) {
- tcpMatchBuilder.setTcpSourcePortMask(new PortNumber(portMask));
+ tcpMatchBuilder.setTcpSourcePortMask(new PortNumber(readUint16(message)));
}
builder.setLayer4Match(tcpMatchBuilder.build());
} else if (builder.getLayer4Match() instanceof TcpMatch
&& ((TcpMatch) builder.getLayer4Match()).getTcpSourcePort() == null) {
TcpMatchBuilder tcpMatchBuilder = new TcpMatchBuilder((TcpMatch) builder.getLayer4Match())
- .setTcpSourcePort(new PortNumber(port));
+ .setTcpSourcePort(port);
if (hasMask) {
- tcpMatchBuilder.setTcpSourcePortMask(new PortNumber(portMask));
+ tcpMatchBuilder.setTcpSourcePortMask(new PortNumber(readUint16(message)));
}
builder.setLayer4Match(tcpMatchBuilder.build());
} else {
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.TunnelBuilder;
public class TunnelIdEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
final boolean hasMask = processHeader(message);
- final byte[] tunnelId = new byte[Long.BYTES];
- message.readBytes(tunnelId);
final TunnelBuilder tunnelBuilder = new TunnelBuilder()
- .setTunnelId(new BigInteger(1, tunnelId));
+ .setTunnelId(readUint64(message));
if (hasMask) {
- final byte[] tunnelMask = new byte[Long.BYTES];
- message.readBytes(tunnelMask);
- tunnelBuilder.setTunnelMask(new BigInteger(1, tunnelMask));
+ tunnelBuilder.setTunnelMask(readUint64(message));
}
if (builder.getTunnel() == null) {
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
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.flow.types.rev131026.flow.MatchBuilder;
public class UdpDestinationPortEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
boolean hasMask = processHeader(message);
- final int port = message.readUnsignedShort();
- final int portMask = hasMask ? message.readUnsignedShort() : 0;
+ final PortNumber port = new PortNumber(readUint16(message));
if (builder.getLayer4Match() == null) {
UdpMatchBuilder udpMatchBuilder = new UdpMatchBuilder()
- .setUdpDestinationPort(new PortNumber(port));
+ .setUdpDestinationPort(port);
if (hasMask) {
- udpMatchBuilder.setUdpDestinationPortMask(new PortNumber(portMask));
+ udpMatchBuilder.setUdpDestinationPortMask(new PortNumber(readUint16(message)));
}
builder.setLayer4Match(udpMatchBuilder.build());
} else if (builder.getLayer4Match() instanceof UdpMatch
&& ((UdpMatch) builder.getLayer4Match()).getUdpDestinationPort() == null) {
UdpMatchBuilder udpMatchBuilder = new UdpMatchBuilder((UdpMatch) builder.getLayer4Match())
- .setUdpDestinationPort(new PortNumber(port));
+ .setUdpDestinationPort(port);
if (hasMask) {
- udpMatchBuilder.setUdpDestinationPortMask(new PortNumber(portMask));
+ udpMatchBuilder.setUdpDestinationPortMask(new PortNumber(readUint16(message)));
}
builder.setLayer4Match(udpMatchBuilder.build());
} else {
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+
import io.netty.buffer.ByteBuf;
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.flow.types.rev131026.flow.MatchBuilder;
public class UdpSourcePortEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
boolean hasMask = processHeader(message);
- final int port = message.readUnsignedShort();
- final int portMask = hasMask ? message.readUnsignedShort() : 0;
+ final PortNumber port = new PortNumber(readUint16(message));
if (builder.getLayer4Match() == null) {
UdpMatchBuilder udpMatchBuilder = new UdpMatchBuilder()
- .setUdpSourcePort(new PortNumber(port));
+ .setUdpSourcePort(port);
if (hasMask) {
- udpMatchBuilder.setUdpSourcePortMask(new PortNumber(portMask));
+ udpMatchBuilder.setUdpSourcePortMask(new PortNumber(readUint16(message)));
}
builder.setLayer4Match(udpMatchBuilder.build());
} else if (builder.getLayer4Match() instanceof UdpMatch
&& ((UdpMatch) builder.getLayer4Match()).getUdpSourcePort() == null) {
UdpMatchBuilder udpMatchBuilder = new UdpMatchBuilder((UdpMatch) builder.getLayer4Match())
- .setUdpSourcePort(new PortNumber(port));
+ .setUdpSourcePort(port);
if (hasMask) {
- udpMatchBuilder.setUdpSourcePortMask(new PortNumber(portMask));
+ udpMatchBuilder.setUdpSourcePortMask(new PortNumber(readUint16(message)));
}
builder.setLayer4Match(udpMatchBuilder.build());
} else {
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
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.VlanMatchBuilder;
+import org.opendaylight.yangtools.yang.common.Uint8;
public class VlanPcpEntryDeserializer extends AbstractMatchEntryDeserializer {
@Override
- public void deserializeEntry(ByteBuf message, MatchBuilder builder) {
+ public void deserializeEntry(final ByteBuf message, final MatchBuilder builder) {
processHeader(message);
- final short pcp = message.readUnsignedByte();
+ final Uint8 pcp = readUint8(message);
if (builder.getVlanMatch() == null) {
builder.setVlanMatch(new VlanMatchBuilder()
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistryInjector;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.FlowModCommand;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
public class FlowMessageDeserializer implements OFDeserializer<FlowMessage>, DeserializerRegistryInjector {
final FlowMessageBuilder builder = new FlowMessageBuilder()
.setVersion(EncodeConstants.OF_VERSION_1_3)
.setXid(readUint32(message))
- .setCookie(new FlowCookie(BigInteger.valueOf(message.readLong())))
- .setCookieMask(new FlowCookie(BigInteger.valueOf(message.readLong())))
+ .setCookie(new FlowCookie(readUint64(message)))
+ .setCookieMask(new FlowCookie(readUint64(message)))
.setTableId(readUint8(message))
.setCommand(FlowModCommand.forValue(message.readUnsignedByte()))
.setIdleTimeout(readUint16(message))
final int length = message.readableBytes();
if (length > 0) {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list
- .Instruction> instructions = new ArrayList<>();
+ final var instructions = BindingMap.<InstructionKey,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction>
+ orderedBuilder();
final int startIndex = message.readerIndex();
int offset = 0;
}
instructions.add(new InstructionBuilder()
- .withKey(new InstructionKey(offset))
.setOrder(offset)
.setInstruction(deserializer.deserialize(message))
.build());
}
builder.setInstructions(new InstructionsBuilder()
- .setInstruction(instructions)
+ .setInstruction(instructions.build())
.build());
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter32;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter64;
private static final byte PADDING_IN_AGGREGATE_HEADER = 4;
@Override
- public MultipartReplyBody deserialize(ByteBuf message) {
- final byte[] packetCount = new byte[Long.BYTES];
- message.readBytes(packetCount);
- final byte[] byteCount = new byte[Long.BYTES];
- message.readBytes(byteCount);
-
+ public MultipartReplyBody deserialize(final ByteBuf message) {
final MultipartReplyFlowAggregateStatsBuilder builder = new MultipartReplyFlowAggregateStatsBuilder()
- .setPacketCount(new Counter64(new BigInteger(1, packetCount)))
- .setByteCount(new Counter64(new BigInteger(1, byteCount)))
- .setFlowCount(new Counter32(message.readUnsignedInt()));
-
+ .setPacketCount(new Counter64(readUint64(message)))
+ .setByteCount(new Counter64(readUint64(message)))
+ .setFlowCount(new Counter32(readUint32(message)));
message.skipBytes(PADDING_IN_AGGREGATE_HEADER);
+
return builder.build();
}
}
* 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.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.duration.DurationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.reply.MultipartReplyBody;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
public class MultipartReplyFlowStatsDeserializer implements OFDeserializer<MultipartReplyBody>,
DeserializerRegistryInjector {
private DeserializerRegistry registry;
@Override
- public MultipartReplyBody deserialize(ByteBuf message) {
+ public MultipartReplyBody deserialize(final ByteBuf message) {
final MultipartReplyFlowStatsBuilder builder = new MultipartReplyFlowStatsBuilder();
final List<FlowAndStatisticsMapList> items = new ArrayList<>();
final int itemLength = message.readUnsignedShort();
final ByteBuf itemMessage = message.readSlice(itemLength - Short.BYTES);
- itemBuilder.setTableId(itemMessage.readUnsignedByte());
+ itemBuilder.setTableId(readUint8(itemMessage));
itemMessage.skipBytes(PADDING_IN_FLOW_STATS_HEADER_01);
itemBuilder
.setDuration(new DurationBuilder()
- .setSecond(new Counter32(itemMessage.readUnsignedInt()))
- .setNanosecond(new Counter32(itemMessage.readUnsignedInt()))
+ .setSecond(new Counter32(readUint32(itemMessage)))
+ .setNanosecond(new Counter32(readUint32(itemMessage)))
.build())
- .setPriority(itemMessage.readUnsignedShort())
- .setIdleTimeout(itemMessage.readUnsignedShort())
- .setHardTimeout(itemMessage.readUnsignedShort())
+ .setPriority(readUint16(itemMessage))
+ .setIdleTimeout(readUint16(itemMessage))
+ .setHardTimeout(readUint16(itemMessage))
.setFlags(createFlowModFlagsFromBitmap(itemMessage.readUnsignedShort()));
itemMessage.skipBytes(PADDING_IN_FLOW_STATS_HEADER_02);
- final byte[] cookie = new byte[Long.BYTES];
- itemMessage.readBytes(cookie);
- final byte[] packetCount = new byte[Long.BYTES];
- itemMessage.readBytes(packetCount);
- final byte[] byteCount = new byte[Long.BYTES];
- itemMessage.readBytes(byteCount);
-
itemBuilder
- .setCookie(new FlowCookie(new BigInteger(1, cookie)))
+ .setCookie(new FlowCookie(readUint64(itemMessage)))
.setCookieMask(new FlowCookie(OFConstants.DEFAULT_COOKIE_MASK))
- .setPacketCount(new Counter64(new BigInteger(1, packetCount)))
- .setByteCount(new Counter64(new BigInteger(1, byteCount)));
+ .setPacketCount(new Counter64(readUint64(itemMessage)))
+ .setByteCount(new Counter64(readUint64(itemMessage)));
final OFDeserializer<Match> matchDeserializer =
Preconditions.checkNotNull(registry).getDeserializer(MATCH_KEY);
final int length = itemMessage.readableBytes();
if (length > 0) {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list
- .Instruction> instructions = new ArrayList<>();
+ final var instructions = BindingMap.<InstructionKey,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction>
+ orderedBuilder();
final int startIndex = itemMessage.readerIndex();
int offset = 0;
while (itemMessage.readerIndex() - startIndex < length) {
instructions.add(new InstructionBuilder()
- .withKey(new InstructionKey(offset))
.setOrder(offset)
.setInstruction(InstructionUtil
.readInstruction(EncodeConstants.OF13_VERSION_ID, itemMessage, registry))
offset++;
}
- itemBuilder.setInstructions(new InstructionsBuilder()
- .setInstruction(instructions)
- .build());
+ itemBuilder.setInstructions(new InstructionsBuilder().setInstruction(instructions.build()).build());
}
items.add(itemBuilder.build());
.build();
}
- private static FlowModFlags createFlowModFlagsFromBitmap(int input) {
+ private static FlowModFlags createFlowModFlagsFromBitmap(final int input) {
final Boolean ofp_FF_SendFlowRem = (input & 1) != 0;
final Boolean ofp_FF_CheckOverlap = (input & 1 << 1) != 0;
final Boolean ofp_FF_ResetCounts = (input & 1 << 2) != 0;
}
@Override
- public void injectDeserializerRegistry(DeserializerRegistry deserializerRegistry) {
+ public void injectDeserializerRegistry(final DeserializerRegistry deserializerRegistry) {
registry = deserializerRegistry;
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter32;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter64;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.multipart.reply.multipart.reply.body.MultipartReplyFlowTableStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.reply.MultipartReplyBody;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableId;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
public class MultipartReplyFlowTableStatsDeserializer implements OFDeserializer<MultipartReplyBody> {
private static final byte PADDING_IN_TABLE_HEADER = 3;
@Override
- public MultipartReplyBody deserialize(ByteBuf message) {
+ public MultipartReplyBody deserialize(final ByteBuf message) {
final MultipartReplyFlowTableStatsBuilder builder = new MultipartReplyFlowTableStatsBuilder();
- final List<FlowTableAndStatisticsMap> items = new ArrayList<>();
+ final var items = BindingMap.<FlowTableAndStatisticsMapKey, FlowTableAndStatisticsMap>orderedBuilder();
while (message.readableBytes() > 0) {
final FlowTableAndStatisticsMapBuilder itemBuilder = new FlowTableAndStatisticsMapBuilder()
- .setTableId(new TableId(message.readUnsignedByte()));
+ .setTableId(new TableId(readUint8(message)));
message.skipBytes(PADDING_IN_TABLE_HEADER);
- itemBuilder
- .withKey(new FlowTableAndStatisticsMapKey(itemBuilder.getTableId()))
- .setActiveFlows(new Counter32(message.readUnsignedInt()));
-
- final byte[] packetsLooked = new byte[Long.BYTES];
- message.readBytes(packetsLooked);
- final byte[] packetsMatched = new byte[Long.BYTES];
- message.readBytes(packetsMatched);
-
items.add(itemBuilder
- .setPacketsLookedUp(new Counter64(new BigInteger(1, packetsLooked)))
- .setPacketsMatched(new Counter64(new BigInteger(1, packetsMatched)))
+ .setActiveFlows(new Counter32(readUint32(message)))
+ .setPacketsLookedUp(new Counter64(readUint64(message)))
+ .setPacketsMatched(new Counter64(readUint64(message)))
.build());
}
return builder
- .setFlowTableAndStatisticsMap(items)
+ .setFlowTableAndStatisticsMap(items.build())
.build();
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistryInjector;
.setGroupType(GroupTypes.forValue(message.readUnsignedByte()));
message.skipBytes(PADDING_IN_GROUP_DESC_HEADER);
- itemBuilder.setGroupId(new GroupId(message.readUnsignedInt()));
- itemBuilder.withKey(new GroupDescStatsKey(itemBuilder.getGroupId()));
+ itemBuilder.setGroupId(new GroupId(readUint32(message)));
final var subItems = BindingMap.<BucketKey, Bucket>orderedBuilder();
int actualLength = GROUP_DESC_HEADER_LENGTH;
final BucketBuilder bucketBuilder = new BucketBuilder()
.setBucketId(new BucketId(bucketKey))
- .withKey(new BucketKey(new BucketId(bucketKey)))
- .setWeight(message.readUnsignedShort())
- .setWatchPort(message.readUnsignedInt())
- .setWatchGroup(message.readUnsignedInt());
+ .setWeight(readUint16(message))
+ .setWatchPort(readUint32(message))
+ .setWatchGroup(readUint32(message));
message.skipBytes(PADDING_IN_BUCKETS_HEADER);
final var actions = BindingMap.<ActionKey, Action>orderedBuilder();
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.DurationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.buckets.BucketCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.buckets.BucketCounterBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.buckets.BucketCounterKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply.GroupStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply.GroupStatsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply.GroupStatsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.reply.MultipartReplyBody;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class MultipartReplyGroupStatsDeserializer implements OFDeserializer<MultipartReplyBody> {
private static final byte PADDING_IN_GROUP_HEADER_01 = 2;
private static final byte BUCKET_COUNTER_LENGTH = 16;
@Override
- public MultipartReplyBody deserialize(ByteBuf message) {
+ public MultipartReplyBody deserialize(final ByteBuf message) {
final MultipartReplyGroupStatsBuilder builder = new MultipartReplyGroupStatsBuilder();
final List<GroupStats> items = new ArrayList<>();
message.skipBytes(PADDING_IN_GROUP_HEADER_01);
final GroupStatsBuilder itemBuilder = new GroupStatsBuilder()
- .setGroupId(new GroupId(message.readUnsignedInt()))
- .setRefCount(new Counter32(message.readUnsignedInt()));
+ .setGroupId(new GroupId(readUint32(message)))
+ .setRefCount(new Counter32(readUint32(message)));
message.skipBytes(PADDING_IN_GROUP_HEADER_02);
- final byte[] packetCountg = new byte[Long.BYTES];
- message.readBytes(packetCountg);
- final byte[] byteCountg = new byte[Long.BYTES];
- message.readBytes(byteCountg);
-
itemBuilder
- .withKey(new GroupStatsKey(itemBuilder.getGroupId()))
- .setPacketCount(new Counter64(new BigInteger(1, packetCountg)))
- .setByteCount(new Counter64(new BigInteger(1, byteCountg)))
+ .setPacketCount(new Counter64(readUint64(message)))
+ .setByteCount(new Counter64(readUint64(message)))
.setDuration(new DurationBuilder()
- .setSecond(new Counter32(message.readUnsignedInt()))
- .setNanosecond(new Counter32(message.readUnsignedInt()))
+ .setSecond(new Counter32(readUint32(message)))
+ .setNanosecond(new Counter32(readUint32(message)))
.build());
final List<BucketCounter> subItems = new ArrayList<>();
int actualLength = GROUP_BODY_LENGTH;
- long bucketKey = 0;
+ int bucketKey = 0;
while (actualLength < itemLength) {
- final byte[] packetCount = new byte[Long.BYTES];
- message.readBytes(packetCount);
- final byte[] byteCount = new byte[Long.BYTES];
- message.readBytes(byteCount);
-
subItems.add(new BucketCounterBuilder()
- .setBucketId(new BucketId(bucketKey))
- .withKey(new BucketCounterKey(new BucketId(bucketKey)))
- .setPacketCount(new Counter64(new BigInteger(1, packetCount)))
- .setByteCount(new Counter64(new BigInteger(1, byteCount)))
+ .setBucketId(new BucketId(Uint32.valueOf(bucketKey)))
+ .setPacketCount(new Counter64(readUint64(message)))
+ .setByteCount(new Counter64(readUint64(message)))
.build());
bucketKey++;
* 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.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.reply.MultipartReplyBody;
-
+import org.opendaylight.yangtools.yang.common.Uint32;
public class MultipartReplyMessageDeserializer implements OFDeserializer<MultipartReply>, DeserializerRegistryInjector {
private DeserializerRegistry registry;
@Override
- public MultipartReply deserialize(ByteBuf message) {
- final long xid = message.readUnsignedInt();
+ public MultipartReply deserialize(final ByteBuf message) {
+ final Uint32 xid = readUint32(message);
final int type = message.readUnsignedShort();
final boolean reqMore = (message.readUnsignedShort() & 0x01) != 0;
message.skipBytes(PADDING_IN_MULTIPART_REPLY_HEADER);
}
@Override
- public void injectDeserializerRegistry(DeserializerRegistry deserializerRegistry) {
+ public void injectDeserializerRegistry(final DeserializerRegistry deserializerRegistry) {
registry = deserializerRegistry;
}
* 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.deserialization.multipart;
+import static java.util.Objects.requireNonNull;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.MeterBandHeaderKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.meter.band.headers.meter.band.header.MeterBandTypesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.reply.MultipartReplyBody;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
public class MultipartReplyMeterConfigDeserializer implements OFDeserializer<MultipartReplyBody>,
DeserializerRegistryInjector {
-
- private static final Logger LOG = LoggerFactory.getLogger(MultipartReplyMeterConfigDeserializer.class);
-
private static final byte METER_CONFIG_LENGTH = 8;
private static final int OFPMBTDROP = 1;
private static final int OFPMBTDSCP = 2;
private static final byte PADDING_IN_METER_BAND_DROP_HEADER = 4;
private static final byte PADDING_IN_METER_BAND_DSCP_HEADER = 3;
- private DeserializerRegistry registry;
+ private DeserializerRegistry registry = null;
@Override
- public MultipartReplyBody deserialize(ByteBuf message) {
+ public MultipartReplyBody deserialize(final ByteBuf message) {
final MultipartReplyMeterConfigBuilder builder = new MultipartReplyMeterConfigBuilder();
final List<MeterConfigStats> items = new ArrayList<>();
final MeterConfigStatsBuilder itemBuilder = new MeterConfigStatsBuilder()
.setFlags(readMeterFlags(message))
- .setMeterId(new MeterId(message.readUnsignedInt()));
+ .setMeterId(new MeterId(readUint32(message)));
final List<MeterBandHeader> subItems = new ArrayList<>();
int actualLength = METER_CONFIG_LENGTH;
.setFlags(new MeterBandType(true, false, false))
.build())
.setBandType(new DropBuilder()
- .setDropRate(message.readUnsignedInt())
- .setDropBurstSize(message.readUnsignedInt())
+ .setDropRate(readUint32(message))
+ .setDropBurstSize(readUint32(message))
.build());
message.skipBytes(PADDING_IN_METER_BAND_DROP_HEADER);
break;
.setFlags(new MeterBandType(false, true, false))
.build())
.setBandType(new DscpRemarkBuilder()
- .setDscpRemarkRate(message.readUnsignedInt())
- .setDscpRemarkBurstSize(message.readUnsignedInt())
- .setPrecLevel(message.readUnsignedByte())
+ .setDscpRemarkRate(readUint32(message))
+ .setDscpRemarkBurstSize(readUint32(message))
+ .setPrecLevel(readUint8(message))
.build());
message.skipBytes(PADDING_IN_METER_BAND_DSCP_HEADER);
break;
.build();
}
- private static MeterFlags readMeterFlags(ByteBuf message) {
+ private static MeterFlags readMeterFlags(final ByteBuf message) {
int input = message.readUnsignedShort();
- final Boolean mfKbps = (input & (1)) != 0;
- final Boolean mfPktps = (input & (1 << 1)) != 0;
- final Boolean mfBurst = (input & (1 << 2)) != 0;
- final Boolean mfStats = (input & (1 << 3)) != 0;
+ final Boolean mfKbps = (input & 1) != 0;
+ final Boolean mfPktps = (input & 1 << 1) != 0;
+ final Boolean mfBurst = (input & 1 << 2) != 0;
+ final Boolean mfStats = (input & 1 << 3) != 0;
return new MeterFlags(mfBurst, mfKbps, mfPktps, mfStats);
}
@Override
- public void injectDeserializerRegistry(DeserializerRegistry deserializerRegistry) {
- registry = deserializerRegistry;
+ public void injectDeserializerRegistry(final DeserializerRegistry deserializerRegistry) {
+ registry = requireNonNull(deserializerRegistry);
}
}
* 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.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.List;
public class MultipartReplyMeterFeaturesDeserializer implements OFDeserializer<MultipartReplyBody> {
@Override
- public MultipartReplyBody deserialize(ByteBuf message) {
+ public MultipartReplyBody deserialize(final ByteBuf message) {
return new MultipartReplyMeterFeaturesBuilder()
- .setMaxMeter(new Counter32(message.readUnsignedInt()))
+ .setMaxMeter(new Counter32(readUint32(message)))
.setMeterBandSupported(readMeterBands(message))
.setMeterCapabilitiesSupported(readMeterCapabilities(message))
- .setMaxBands(message.readUnsignedByte())
- .setMaxColor(message.readUnsignedByte())
+ .setMaxBands(readUint8(message))
+ .setMaxColor(readUint8(message))
.build();
}
- private static List<Class<? extends MeterBand>> readMeterBands(ByteBuf message) {
+ private static List<Class<? extends MeterBand>> readMeterBands(final ByteBuf message) {
final List<Class<? extends MeterBand>> bandTypes = new ArrayList<>();
final long typesMask = message.readUnsignedInt();
- final boolean mbtDrop = (typesMask & (1)) != 0;
- final boolean mbtDscpRemark = (typesMask & (1 << 1)) != 0;
+ final boolean mbtDrop = (typesMask & 1) != 0;
+ final boolean mbtDscpRemark = (typesMask & 1 << 1) != 0;
if (mbtDrop) {
bandTypes.add(MeterBandDrop.class);
return bandTypes;
}
- private static List<Class<? extends MeterCapability>> readMeterCapabilities(ByteBuf message) {
+ private static List<Class<? extends MeterCapability>> readMeterCapabilities(final ByteBuf message) {
final List<Class<? extends MeterCapability>> meterCapabilities = new ArrayList<>();
final long capabilitiesMask = message.readUnsignedInt();
- final boolean mfKbps = (capabilitiesMask & (1)) != 0;
- final boolean mfPktps = (capabilitiesMask & (1 << 1)) != 0;
- final boolean mfBurst = (capabilitiesMask & (1 << 2)) != 0;
- final boolean mfStats = (capabilitiesMask & (1 << 3)) != 0;
+ final boolean mfKbps = (capabilitiesMask & 1) != 0;
+ final boolean mfPktps = (capabilitiesMask & 1 << 1) != 0;
+ final boolean mfBurst = (capabilitiesMask & 1 << 2) != 0;
+ final boolean mfStats = (capabilitiesMask & 1 << 3) != 0;
if (mfKbps) {
meterCapabilities.add(MeterKbps.class);
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter32;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Counter64;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStatsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.reply.MultipartReplyBody;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class MultipartReplyMeterStatsDeserializer implements OFDeserializer<MultipartReplyBody> {
private static final byte PADDING_IN_METER_STATS_HEADER = 6;
private static final byte METER_BAND_STATS_LENGTH = 16;
@Override
- public MultipartReplyBody deserialize(ByteBuf message) {
- final MultipartReplyMeterStatsBuilder builder = new MultipartReplyMeterStatsBuilder();
- final List<MeterStats> items = new ArrayList<>();
+ public MultipartReplyBody deserialize(final ByteBuf message) {
+ final var items = BindingMap.<MeterStatsKey, MeterStats>orderedBuilder();
while (message.readableBytes() > 0) {
final MeterStatsBuilder itemBuilder = new MeterStatsBuilder()
- .setMeterId(new MeterId(message.readUnsignedInt()));
+ .setMeterId(new MeterId(readUint32(message)));
final int itemLength = message.readUnsignedShort();
message.skipBytes(PADDING_IN_METER_STATS_HEADER);
itemBuilder
- .withKey(new MeterStatsKey(itemBuilder.getMeterId()))
- .setFlowCount(new Counter32(message.readUnsignedInt()));
-
- final byte[] packetCount = new byte[Long.BYTES];
- message.readBytes(packetCount);
- final byte[] byteCount = new byte[Long.BYTES];
- message.readBytes(byteCount);
+ .setFlowCount(new Counter32(readUint32(message)));
itemBuilder
- .setPacketInCount(new Counter64(new BigInteger(1, packetCount)))
- .setByteInCount(new Counter64(new BigInteger(1, byteCount)))
+ .setPacketInCount(new Counter64(readUint64(message)))
+ .setByteInCount(new Counter64(readUint64(message)))
.setDuration(new DurationBuilder()
- .setSecond(new Counter32(message.readUnsignedInt()))
- .setNanosecond(new Counter32(message.readUnsignedInt()))
+ .setSecond(new Counter32(readUint32(message)))
+ .setNanosecond(new Counter32(readUint32(message)))
.build());
- final List<BandStat> subItems = new ArrayList<>();
+ final var subItems = BindingMap.<BandStatKey, BandStat>orderedBuilder();
int actualLength = METER_BODY_LENGTH;
- long bandKey = 0;
+ int bandKey = 0;
while (actualLength < itemLength) {
- final byte[] packetCountB = new byte[Long.BYTES];
- message.readBytes(packetCountB);
- final byte[] byteCountB = new byte[Long.BYTES];
- message.readBytes(byteCountB);
-
subItems.add(new BandStatBuilder()
- .setBandId(new BandId(bandKey))
- .withKey(new BandStatKey(new BandId(bandKey)))
- .setPacketBandCount(new Counter64(new BigInteger(1, packetCountB)))
- .setByteBandCount(new Counter64(new BigInteger(1, byteCountB)))
+ .setBandId(new BandId(Uint32.valueOf(bandKey++)))
+ .setPacketBandCount(new Counter64(readUint64(message)))
+ .setByteBandCount(new Counter64(readUint64(message)))
.build());
- bandKey++;
actualLength += METER_BAND_STATS_LENGTH;
}
items.add(itemBuilder
.setMeterBandStats(new MeterBandStatsBuilder()
- .setBandStat(subItems)
+ .setBandStat(subItems.build())
.build())
.build());
}
- return builder
- .setMeterStats(items)
- .build();
+ return new MultipartReplyMeterStatsBuilder().setMeterStats(items.build()).build();
}
}
* 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.deserialization.multipart;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
+
import io.netty.buffer.ByteBuf;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.multipart.reply.multipart.reply.body.MultipartReplyQueueStatsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMapBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMapKey;
public class MultipartReplyQueueStatsDeserializer implements OFDeserializer<MultipartReplyBody> {
@Override
- public MultipartReplyBody deserialize(ByteBuf message) {
+ public MultipartReplyBody deserialize(final ByteBuf message) {
final MultipartReplyQueueStatsBuilder builder = new MultipartReplyQueueStatsBuilder();
final List<QueueIdAndStatisticsMap> items = new ArrayList<>();
final long port = message.readUnsignedInt();
final NodeConnectorId nodeConnectorId = new NodeConnectorId(OpenflowPortsUtil
.getProtocolAgnosticPortUri(EncodeConstants.OF13_VERSION_ID, port));
- final QueueId queueId = new QueueId(message.readUnsignedInt());
-
- final byte[] txBytes = new byte[Long.BYTES];
- message.readBytes(txBytes);
- final byte[] txPackets = new byte[Long.BYTES];
- message.readBytes(txPackets);
- final byte[] txErrors = new byte[Long.BYTES];
- message.readBytes(txErrors);
items.add(new QueueIdAndStatisticsMapBuilder()
- .withKey(new QueueIdAndStatisticsMapKey(nodeConnectorId, queueId))
.setNodeConnectorId(nodeConnectorId)
- .setQueueId(queueId)
- .setTransmittedBytes(new Counter64(new BigInteger(1, txBytes)))
- .setTransmittedPackets(new Counter64(new BigInteger(1, txPackets)))
- .setTransmissionErrors(new Counter64(new BigInteger(1, txErrors)))
+ .setQueueId(new QueueId(readUint32(message)))
+ .setTransmittedBytes(new Counter64(readUint64(message)))
+ .setTransmittedPackets(new Counter64(readUint64(message)))
+ .setTransmissionErrors(new Counter64(readUint64(message)))
.setDuration(new DurationBuilder()
- .setSecond(new Counter32(message.readUnsignedInt()))
- .setNanosecond(new Counter32(message.readUnsignedInt()))
+ .setSecond(new Counter32(readUint32(message)))
+ .setNanosecond(new Counter32(readUint32(message)))
.build())
.build());
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.reply.MultipartReplyBody;
return tableIds;
}
- private List<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list
- .Instruction> readInstructions(final ByteBuf message, final int length) {
-
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list
- .Instruction> instructions = new ArrayList<>();
+ private Map<InstructionKey, Instruction> readInstructions(final ByteBuf message, final int length) {
+ final var instructions = BindingMap.<InstructionKey, Instruction>orderedBuilder();
final int startIndex = message.readerIndex();
int offset = 0;
}
}
- return instructions;
+ return instructions.build();
}
@SuppressWarnings("checkstyle:LineLength")
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import java.math.BigInteger;
import java.util.Collection;
import java.util.concurrent.ExecutionException;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
final RoleRequestInputBuilder roleRequestInputBuilder = new RoleRequestInputBuilder();
roleRequestInputBuilder.setRole(toOFJavaRole(OfpRole.NOCHANGE));
roleRequestInputBuilder.setVersion(version);
- roleRequestInputBuilder.setGenerationId(BigInteger.ZERO);
+ roleRequestInputBuilder.setGenerationId(Uint64.ZERO);
final SettableFuture<Uint64> finalFuture = SettableFuture.create();
final ListenableFuture<RpcResult<RoleRequestOutput>> genIdListenableFuture =
* 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.services.batch;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.flow._case.FlatBatchAddFlow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.update.flow._case.FlatBatchUpdateFlow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailure;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailureBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailureKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.batch.failure.batch.item.id.choice.FlatBatchFailureFlowIdCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.RemoveFlowsBatchInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.UpdateFlowsBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.UpdateFlowsBatchInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.add.flows.batch.input.BatchAddFlows;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.add.flows.batch.input.BatchAddFlowsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.batch.flow.output.list.grouping.BatchFailedFlowsOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.remove.flows.batch.input.BatchRemoveFlows;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.remove.flows.batch.input.BatchRemoveFlowsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.update.flows.batch.input.BatchUpdateFlows;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.update.flows.batch.input.BatchUpdateFlowsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
/**
* Transform between FlatBatch API and flow batch API.
* .opendaylight.flows.service.rev160314.SalFlowsBatchService#addFlowsBatch(AddFlowsBatchInput)}
*/
public static AddFlowsBatchInput adaptFlatBatchAddFlow(final BatchPlanStep planStep, final NodeRef node) {
- final List<BatchAddFlows> batchFlows = new ArrayList<>();
- for (FlatBatchAddFlow batchAddFlows : planStep.<FlatBatchAddFlow>getTaskBag()) {
- final BatchAddFlows addFlows = new BatchAddFlowsBuilder((Flow) batchAddFlows)
- .setFlowId(batchAddFlows.getFlowId())
- .build();
- batchFlows.add(addFlows);
- }
+ final var batchFlows = planStep.<FlatBatchAddFlow>getTaskBag().stream()
+ .map(batchAddFlows -> new BatchAddFlowsBuilder((Flow) batchAddFlows)
+ .setFlowId(batchAddFlows.getFlowId())
+ .build())
+ .collect(BindingMap.toOrderedMap());
return new AddFlowsBatchInputBuilder()
.setBarrierAfter(planStep.isBarrierAfter())
* .opendaylight.flows.service.rev160314.SalFlowsBatchService#removeFlowsBatch(RemoveFlowsBatchInput)}
*/
public static RemoveFlowsBatchInput adaptFlatBatchRemoveFlow(final BatchPlanStep planStep, final NodeRef node) {
- final List<BatchRemoveFlows> batchFlows = new ArrayList<>();
- for (FlatBatchRemoveFlow batchRemoveFlow : planStep.<FlatBatchRemoveFlow>getTaskBag()) {
- final BatchRemoveFlows removeFlows = new BatchRemoveFlowsBuilder((Flow) batchRemoveFlow)
- .setFlowId(batchRemoveFlow.getFlowId())
- .build();
- batchFlows.add(removeFlows);
- }
+ final var batchFlows = planStep.<FlatBatchRemoveFlow>getTaskBag().stream()
+ .map(batchRemoveFlow -> new BatchRemoveFlowsBuilder((Flow) batchRemoveFlow)
+ .setFlowId(batchRemoveFlow.getFlowId())
+ .build())
+ .collect(BindingMap.toOrderedMap());
return new RemoveFlowsBatchInputBuilder()
.setBarrierAfter(planStep.isBarrierAfter())
* .opendaylight.flows.service.rev160314.SalFlowsBatchService#updateFlowsBatch(UpdateFlowsBatchInput)}
*/
public static UpdateFlowsBatchInput adaptFlatBatchUpdateFlow(final BatchPlanStep planStep, final NodeRef node) {
- final List<BatchUpdateFlows> batchFlows = new ArrayList<>();
- for (FlatBatchUpdateFlow batchUpdateFlow : planStep.<FlatBatchUpdateFlow>getTaskBag()) {
- final BatchUpdateFlows updateFlows = new BatchUpdateFlowsBuilder(batchUpdateFlow)
- .build();
- batchFlows.add(updateFlows);
- }
+ final var batchFlows = planStep.<FlatBatchUpdateFlow>getTaskBag().stream()
+ .map(batchUpdateFlow -> new BatchUpdateFlowsBuilder(batchUpdateFlow).build())
+ .collect(BindingMap.toOrderedMap());
return new UpdateFlowsBatchInputBuilder()
.setBarrierAfter(planStep.isBarrierAfter())
@VisibleForTesting
static <T extends BatchFlowOutputListGrouping> Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>
convertBatchFlowResult(final int stepOffset) {
- return input -> {
- List<BatchFailure> batchFailures = wrapBatchFlowFailuresForFlat(input, stepOffset);
- ProcessFlatBatchOutputBuilder outputBuilder =
- new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
- return RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
- .withRpcErrors(input.getErrors())
- .withResult(outputBuilder.build())
- .build();
- };
+ return input -> RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
+ .withRpcErrors(input.getErrors())
+ .withResult(new ProcessFlatBatchOutputBuilder()
+ .setBatchFailure(wrapBatchFlowFailuresForFlat(input, stepOffset))
+ .build())
+ .build();
}
- private static <T extends BatchFlowOutputListGrouping> List<BatchFailure> wrapBatchFlowFailuresForFlat(
- final RpcResult<T> input, final int stepOffset) {
- final List<BatchFailure> batchFailures = new ArrayList<>();
- if (input.getResult().getBatchFailedFlowsOutput() != null) {
- for (BatchFailedFlowsOutput stepOutput : input.getResult().nonnullBatchFailedFlowsOutput().values()) {
- final BatchFailure batchFailure = new BatchFailureBuilder()
- .setBatchOrder(stepOffset + stepOutput.getBatchOrder().toJava())
- .setBatchItemIdChoice(new FlatBatchFailureFlowIdCaseBuilder()
- .setFlowId(stepOutput.getFlowId())
- .build())
- .build();
- batchFailures.add(batchFailure);
- }
- }
- return batchFailures;
+ private static <T extends BatchFlowOutputListGrouping>
+ Map<BatchFailureKey, BatchFailure> wrapBatchFlowFailuresForFlat(final RpcResult<T> input,
+ final int stepOffset) {
+ return input.getResult().nonnullBatchFailedFlowsOutput().values().stream()
+ .map(stepOutput -> new BatchFailureBuilder()
+ .setBatchOrder(Uint16.valueOf(stepOffset + stepOutput.getBatchOrder().toJava()))
+ .setBatchItemIdChoice(new FlatBatchFailureFlowIdCaseBuilder().setFlowId(stepOutput.getFlowId()).build())
+ .build())
+ .collect(BindingMap.toOrderedMap());
}
/**
* 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.services.batch;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.group._case.FlatBatchAddGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.update.group._case.FlatBatchUpdateGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailure;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailureBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailureKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.batch.failure.batch.item.id.choice.FlatBatchFailureGroupIdCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.RemoveGroupsBatchInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.UpdateGroupsBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.UpdateGroupsBatchInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.add.groups.batch.input.BatchAddGroups;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.add.groups.batch.input.BatchAddGroupsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.batch.group.output.list.grouping.BatchFailedGroupsOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.remove.groups.batch.input.BatchRemoveGroups;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.remove.groups.batch.input.BatchRemoveGroupsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.update.groups.batch.input.BatchUpdateGroups;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.update.groups.batch.input.BatchUpdateGroupsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
/**
* Transform between FlatBatch API and group batch API.
* .opendaylight.groups.service.rev160315.SalGroupsBatchService#addGroupsBatch(AddGroupsBatchInput)}
*/
public static AddGroupsBatchInput adaptFlatBatchAddGroup(final BatchPlanStep planStep, final NodeRef node) {
- final List<BatchAddGroups> batchGroups = new ArrayList<>();
- for (FlatBatchAddGroup batchAddGroup : planStep.<FlatBatchAddGroup>getTaskBag()) {
- final BatchAddGroups addGroups = new BatchAddGroupsBuilder(batchAddGroup)
+ final var batchGroups = planStep.<FlatBatchAddGroup>getTaskBag().stream()
+ .map(batchAddGroup -> new BatchAddGroupsBuilder(batchAddGroup)
.setGroupId(batchAddGroup.getGroupId())
- .build();
- batchGroups.add(addGroups);
- }
+ .build())
+ .collect(BindingMap.toOrderedMap());
return new AddGroupsBatchInputBuilder()
.setBarrierAfter(planStep.isBarrierAfter())
* .opendaylight.groups.service.rev160315.SalGroupsBatchService#removeGroupsBatch(RemoveGroupsBatchInput)}
*/
public static RemoveGroupsBatchInput adaptFlatBatchRemoveGroup(final BatchPlanStep planStep, final NodeRef node) {
- final List<BatchRemoveGroups> batchGroups = new ArrayList<>();
- for (FlatBatchRemoveGroup batchRemoveGroup : planStep.<FlatBatchRemoveGroup>getTaskBag()) {
- final BatchRemoveGroups removeGroups = new BatchRemoveGroupsBuilder(batchRemoveGroup)
- .setGroupId(batchRemoveGroup.getGroupId())
- .build();
- batchGroups.add(removeGroups);
- }
+ final var batchGroups = planStep.<FlatBatchRemoveGroup>getTaskBag().stream()
+ .map(batchRemoveGroup -> new BatchRemoveGroupsBuilder(batchRemoveGroup)
+ .setGroupId(batchRemoveGroup.getGroupId())
+ .build())
+ .collect(BindingMap.toOrderedMap());
return new RemoveGroupsBatchInputBuilder()
.setBarrierAfter(planStep.isBarrierAfter())
@VisibleForTesting
static <T extends BatchGroupOutputListGrouping> Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>
convertBatchGroupResult(final int stepOffset) {
- return input -> {
- List<BatchFailure> batchFailures = wrapBatchGroupFailuresForFlat(input, stepOffset);
- ProcessFlatBatchOutputBuilder outputBuilder =
- new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
- return RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
- .withRpcErrors(input.getErrors())
- .withResult(outputBuilder.build())
- .build();
- };
+ return input -> RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
+ .withRpcErrors(input.getErrors())
+ .withResult(new ProcessFlatBatchOutputBuilder()
+ .setBatchFailure(wrapBatchGroupFailuresForFlat(input, stepOffset))
+ .build())
+ .build();
}
- private static <T extends BatchGroupOutputListGrouping> List<BatchFailure> wrapBatchGroupFailuresForFlat(
- final RpcResult<T> input, final int stepOffset) {
- final List<BatchFailure> batchFailures = new ArrayList<>();
- if (input.getResult().getBatchFailedGroupsOutput() != null) {
- for (BatchFailedGroupsOutput stepOutput : input.getResult().nonnullBatchFailedGroupsOutput().values()) {
- final BatchFailure batchFailure = new BatchFailureBuilder()
- .setBatchOrder(stepOffset + stepOutput.getBatchOrder().toJava())
- .setBatchItemIdChoice(new FlatBatchFailureGroupIdCaseBuilder()
- .setGroupId(stepOutput.getGroupId())
- .build())
- .build();
- batchFailures.add(batchFailure);
- }
- }
- return batchFailures;
+ private static <T extends BatchGroupOutputListGrouping>
+ Map<BatchFailureKey, BatchFailure> wrapBatchGroupFailuresForFlat(final RpcResult<T> input,
+ final int stepOffset) {
+ return input.getResult().nonnullBatchFailedGroupsOutput().values().stream()
+ .map(stepOutput -> new BatchFailureBuilder()
+ .setBatchOrder(Uint16.valueOf(stepOffset + stepOutput.getBatchOrder().toJava()))
+ .setBatchItemIdChoice(new FlatBatchFailureGroupIdCaseBuilder()
+ .setGroupId(stepOutput.getGroupId())
+ .build())
+ .build())
+ .collect(BindingMap.toOrderedMap());
}
/**
* 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.services.batch;
import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.RemoveMetersBatchInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.UpdateMetersBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.UpdateMetersBatchInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.add.meters.batch.input.BatchAddMeters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.add.meters.batch.input.BatchAddMetersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.batch.meter.output.list.grouping.BatchFailedMetersOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.remove.meters.batch.input.BatchRemoveMeters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.remove.meters.batch.input.BatchRemoveMetersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.update.meters.batch.input.BatchUpdateMeters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.update.meters.batch.input.BatchUpdateMetersBuilder;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
* .opendaylight.meters.service.rev160316.SalMetersBatchService#addMetersBatch(AddMetersBatchInput)}
*/
public static AddMetersBatchInput adaptFlatBatchAddMeter(final BatchPlanStep planStep, final NodeRef node) {
- final List<BatchAddMeters> batchMeters = new ArrayList<>();
- for (FlatBatchAddMeter batchAddMeter : planStep.<FlatBatchAddMeter>getTaskBag()) {
- final BatchAddMeters addMeters = new BatchAddMetersBuilder(batchAddMeter)
- .setMeterId(batchAddMeter.getMeterId())
- .build();
- batchMeters.add(addMeters);
- }
+ final var batchMeters = planStep.<FlatBatchAddMeter>getTaskBag().stream()
+ .map(batchAddMeter -> new BatchAddMetersBuilder(batchAddMeter)
+ .setMeterId(batchAddMeter.getMeterId())
+ .build())
+ .collect(BindingMap.toOrderedMap());
return new AddMetersBatchInputBuilder()
.setBarrierAfter(planStep.isBarrierAfter())
* .opendaylight.meters.service.rev160316.SalMetersBatchService#removeMetersBatch(RemoveMetersBatchInput)}
*/
public static RemoveMetersBatchInput adaptFlatBatchRemoveMeter(final BatchPlanStep planStep, final NodeRef node) {
- final List<BatchRemoveMeters> batchMeters = new ArrayList<>();
- for (FlatBatchRemoveMeter batchRemoveMeter : planStep.<FlatBatchRemoveMeter>getTaskBag()) {
- final BatchRemoveMeters removeMeters = new BatchRemoveMetersBuilder(batchRemoveMeter)
- .setMeterId(batchRemoveMeter.getMeterId())
- .build();
- batchMeters.add(removeMeters);
- }
+ final var batchMeters = planStep.<FlatBatchRemoveMeter>getTaskBag().stream()
+ .map(batchRemoveMeter -> new BatchRemoveMetersBuilder(batchRemoveMeter)
+ .setMeterId(batchRemoveMeter.getMeterId())
+ .build())
+ .collect(BindingMap.toOrderedMap());
return new RemoveMetersBatchInputBuilder()
.setBarrierAfter(planStep.isBarrierAfter())
private final AtomicLong compatibilityXidSeed;
private final OpenflowVersion ofVersion;
- public AbstractCompatibleStatService(RequestContextStack requestContextStack,
- DeviceContext deviceContext,
- AtomicLong compatibilityXidSeed) {
+ public AbstractCompatibleStatService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final AtomicLong compatibilityXidSeed) {
super(requestContextStack, deviceContext);
this.compatibilityXidSeed = compatibilityXidSeed;
ofVersion = OpenflowVersion.get(getVersion());
// hook notification publishing
Futures.addCallback(rpcResultListenableFuture, new FutureCallback<RpcResult<List<MultipartReply>>>() {
@Override
- public void onSuccess(RpcResult<List<MultipartReply>> result) {
+ public void onSuccess(final RpcResult<List<MultipartReply>> result) {
if (result != null && result.isSuccessful()) {
// transform rpc result (raw multipart) to notification
final N flowNotification = transformToNotification(result.getResult(), emulatedTxId);
}
@Override
- public void onFailure(Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
LOG.debug("compatibility callback crashed - NOT emitting notification: {}",
input.getClass().getSimpleName(), throwable);
}
Code Review / openflowplugin.git / commitdiff