package org.opendaylight.protocol.bgp.flowspec;
import io.netty.buffer.ByteBuf;
-import java.util.BitSet;
import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
import org.opendaylight.protocol.bgp.parser.BGPError;
import org.opendaylight.protocol.bgp.parser.impl.message.update.ExtendedCommunitiesAttributeParser;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.protocol.util.ReferenceCache;
private static final int RESERVED = 5;
- private static final int FLAGS_SIZE = 1;
+ private static final int FLAGS_SIZE = 8;
private static final int SAMPLE_BIT = 6;
break;
case TRAFFIC_ACTION_SUBTYPE:
buffer.skipBytes(RESERVED);
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, FLAGS_SIZE));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
final boolean sample = flags.get(SAMPLE_BIT);
final boolean terminal = flags.get(TERMINAL_BIT);
c = new TrafficActionExtendedCommunityCaseBuilder().setTrafficActionExtendedCommunity(new TrafficActionExtendedCommunityBuilder().setSample(sample).setTerminalAction(terminal).build()).build();
else if (ex instanceof TrafficActionExtendedCommunityCase) {
final TrafficActionExtendedCommunity trafficAction = ((TrafficActionExtendedCommunityCase) ex).getTrafficActionExtendedCommunity();
buffer.writeZero(RESERVED);
- final BitSet flags = new BitSet(FLAGS_SIZE);
- if (trafficAction.isSample() != null) {
- flags.set(SAMPLE_BIT, trafficAction.isSample());
- }
- if (trafficAction.isTerminalAction() != null) {
- flags.set(TERMINAL_BIT, trafficAction.isTerminalAction());
- }
- ByteBufWriteUtil.writeBitSet(flags, FLAGS_SIZE, buffer);
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(SAMPLE_BIT, trafficAction.isSample());
+ flags.set(TERMINAL_BIT, trafficAction.isTerminalAction());
+ flags.toByteBuf(buffer);
}
else if (ex instanceof RedirectExtendedCommunityCase) {
final RedirectExtendedCommunity redirect = ((RedirectExtendedCommunityCase) ex).getRedirectExtendedCommunity();
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
-import java.util.BitSet;
import java.util.List;
import org.opendaylight.protocol.bgp.parser.BGPParsingException;
import org.opendaylight.protocol.bgp.parser.spi.NlriParser;
import org.opendaylight.protocol.bgp.parser.spi.NlriSerializer;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.protocol.util.Ipv4Util;
*/
private static final int LENGTH_MAGIC = 61440;
- private static final int END_OF_LIST = 7;
- private static final int AND_BIT = 6;
+ private static final int OPERAND_LENGTH = 8;
+
+ private static final int END_OF_LIST = 0;
+ private static final int AND_BIT = 1;
private static final int LENGTH_BITMASK = 48;
private static final int LENGTH_SHIFT = 4;
- private static final int LESS_THAN = 2;
- private static final int GREATER_THAN = 1;
- private static final int EQUAL = 0;
+ private static final int LESS_THAN = 5;
+ private static final int GREATER_THAN = 6;
+ private static final int EQUAL = 7;
- private static final int NOT = 1;
- private static final int MATCH = 0;
+ private static final int NOT = 6;
+ private static final int MATCH = 7;
- private static final int LAST_FRAGMENT = 7;
- private static final int FIRST_FRAGMENT = 6;
- private static final int IS_A_FRAGMENT = 5;
- private static final int DONT_FRAGMENT = 4;
+ private static final int LAST_FRAGMENT = 4;
+ private static final int FIRST_FRAGMENT = 5;
+ private static final int IS_A_FRAGMENT = 6;
+ private static final int DONT_FRAGMENT = 7;
private static final int MAX_NLRI_LENGTH = 4095;
private static final int MAX_NLRI_LENGTH_ONE_BYTE = 240;
}
private static void serializeNumericOperand(final NumericOperand op, final int length, final ByteBuf buffer) {
- final BitSet bs = new BitSet(Byte.SIZE);
- if (op.isEndOfList() != null) {
- bs.set(END_OF_LIST, op.isEndOfList());
- }
- if (op.isAndBit() != null) {
- bs.set(AND_BIT, op.isAndBit());
- }
- if (op.isLessThan() != null) {
- bs.set(LESS_THAN, op.isLessThan());
- }
- if (op.isGreaterThan() != null) {
- bs.set(GREATER_THAN, op.isGreaterThan());
- }
- if (op.isEquals() != null) {
- bs.set(EQUAL, op.isEquals());
- }
+ final BitArray bs = new BitArray(OPERAND_LENGTH);
+ bs.set(END_OF_LIST, op.isEndOfList());
+ bs.set(AND_BIT, op.isAndBit());
+ bs.set(LESS_THAN, op.isLessThan());
+ bs.set(GREATER_THAN, op.isGreaterThan());
+ bs.set(EQUAL, op.isEquals());
final byte len = (byte) (Integer.numberOfTrailingZeros(length) << LENGTH_SHIFT);
- buffer.writeByte(bs.toByteArray()[0] | len);
+ buffer.writeByte(bs.toByte() | len);
}
private static void serializeBitmaskOperand(final BitmaskOperand op, final int length, final ByteBuf buffer) {
- final BitSet bs = new BitSet(Byte.SIZE);
- if (op.isEndOfList() != null) {
- bs.set(END_OF_LIST, op.isEndOfList());
- }
- if (op.isAndBit() != null) {
- bs.set(AND_BIT, op.isAndBit());
- }
- if (op.isMatch() != null) {
- bs.set(MATCH, op.isMatch());
- }
- if (op.isNot() != null) {
- bs.set(NOT, op.isNot());
- }
+ final BitArray bs = new BitArray(OPERAND_LENGTH);
+ bs.set(END_OF_LIST, op.isEndOfList());
+ bs.set(AND_BIT, op.isAndBit());
+ bs.set(MATCH, op.isMatch());
+ bs.set(NOT, op.isNot());
final byte len = (byte) (Integer.numberOfTrailingZeros(length) << LENGTH_SHIFT);
- buffer.writeByte(bs.toByteArray()[0] | len);
+ buffer.writeByte(bs.toByte() | len);
}
@Override
}
private static NumericOperand parseNumeric(final byte op) {
- final BitSet bs = BitSet.valueOf(new long[] {UnsignedBytes.toInt(op)});
+ final BitArray bs = BitArray.valueOf(op);
return new NumericOperand(bs.get(AND_BIT), bs.get(END_OF_LIST), bs.get(EQUAL), bs.get(GREATER_THAN), bs.get(LESS_THAN));
}
private static BitmaskOperand parseBitmask(final byte op) {
- final BitSet bs = BitSet.valueOf(new long[] {UnsignedBytes.toInt(op)});
+ final BitArray bs = BitArray.valueOf(op);
return new BitmaskOperand(bs.get(AND_BIT), bs.get(END_OF_LIST), bs.get(MATCH), bs.get(NOT));
}
}
private static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev150114.Fragment parseFragment(final byte fragment) {
- final BitSet bs = BitSet.valueOf(new long[] {UnsignedBytes.toInt(fragment)});
+ final BitArray bs = BitArray.valueOf(fragment);
return new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev150114.Fragment(bs.get(DONT_FRAGMENT), bs.get(FIRST_FRAGMENT), bs.get(IS_A_FRAGMENT), bs.get(LAST_FRAGMENT));
}
private static byte serializeFragment(final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev150114.Fragment fragment) {
- final BitSet bs = new BitSet(Byte.SIZE);
- if (fragment.isDoNot() != null) {
- bs.set(DONT_FRAGMENT, fragment.isDoNot());
- }
- if (fragment.isFirst() != null) {
- bs.set(FIRST_FRAGMENT, fragment.isFirst());
- }
- if (fragment.isIsA() != null) {
- bs.set(IS_A_FRAGMENT, fragment.isIsA());
- }
- if (fragment.isLast() != null) {
- bs.set(LAST_FRAGMENT, fragment.isLast());
- }
- return bs.toByteArray()[0];
+ final BitArray bs = new BitArray(Byte.SIZE);
+ bs.set(DONT_FRAGMENT, fragment.isDoNot());
+ bs.set(FIRST_FRAGMENT, fragment.isFirst());
+ bs.set(IS_A_FRAGMENT, fragment.isIsA());
+ bs.set(LAST_FRAGMENT, fragment.isLast());
+ return bs.toByte();
}
}
0x09, 0x12, 04, 01, (byte)0x91, 0x56, (byte) 0xb1,
0x0a, (byte)0x96, (byte) 0xde, (byte) 0xad,
0x0b, (byte)0x86, 0x2a,
- 0x0c, (byte)0x81, (byte)0xf0};
+ 0x0c, (byte)0x81, (byte)0x0f};
@Test
public void testParseLength() {
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.BitSet;
import java.util.List;
import java.util.Map.Entry;
import org.opendaylight.protocol.bgp.linkstate.attribute.sr.SrLinkAttributesParser;
import org.opendaylight.protocol.bgp.linkstate.spi.TlvUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.Ipv4Util;
import org.opendaylight.protocol.util.Ipv6Util;
private static final int BANDWIDTH_LENGTH = 4;
// MPLS protection mask bits
- private static final int LDP_BIT = 7;
- private static final int RSVP_BIT = 6;
+ private static final int FLAGS_SIZE = 8;
+
+ private static final int LDP_BIT = 0;
+ private static final int RSVP_BIT = 1;
/* Link Attribute TLVs */
private static final int REMOTE_IPV4_ROUTER_ID = 1030;
LOG.debug("Parsed Link Protection Type {}", lpt);
break;
case MPLS_PROTOCOL:
- final BitSet bits = BitSet.valueOf(ByteArray.readAllBytes(value));
+ final BitArray bits = BitArray.valueOf(value, FLAGS_SIZE);
builder.setMplsProtocol(new MplsProtocolMask(bits.get(LDP_BIT), bits.get(RSVP_BIT)));
LOG.debug("Parsed MPLS Protocols: {}", builder.getMplsProtocol());
break;
private static void serializeMplsProtocolMask(final MplsProtocolMask mplsProtocolMask, final ByteBuf byteAggregator ) {
if (mplsProtocolMask != null) {
final ByteBuf mplsProtocolMaskBuf = Unpooled.buffer(1);
- final BitSet mask = new BitSet(Byte.SIZE);
- if (mplsProtocolMask.isLdp() != null) {
- mask.set(LDP_BIT, mplsProtocolMask.isLdp());
- }
- if (mplsProtocolMask.isRsvpte() != null) {
- mask.set(RSVP_BIT, mplsProtocolMask.isRsvpte());
- }
- mplsProtocolMaskBuf.writeBytes(mask.toByteArray());
+ final BitArray mask = new BitArray(FLAGS_SIZE);
+ mask.set(LDP_BIT, mplsProtocolMask.isLdp());
+ mask.set(RSVP_BIT, mplsProtocolMask.isRsvpte());
+ mask.toByteBuf(mplsProtocolMaskBuf);
TlvUtil.writeTLV(MPLS_PROTOCOL, mplsProtocolMaskBuf, byteAggregator);
}
}
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
-import java.util.BitSet;
import java.util.List;
import java.util.Map.Entry;
import org.opendaylight.protocol.bgp.linkstate.attribute.sr.SrNodeAttributesParser;
import org.opendaylight.protocol.bgp.linkstate.spi.TlvUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.Ipv4Util;
import org.opendaylight.protocol.util.Ipv6Util;
throw new UnsupportedOperationException();
}
+ private static final int FLAGS_SIZE = 8;
+
// node flag bits
- private static final int OVERLOAD_BIT = 7;
- private static final int ATTACHED_BIT = 6;
- private static final int EXTERNAL_BIT = 5;
- private static final int ABBR_BIT = 4;
+ private static final int OVERLOAD_BIT = 0;
+ private static final int ATTACHED_BIT = 1;
+ private static final int EXTERNAL_BIT = 2;
+ private static final int ABBR_BIT = 3;
/* Node Attribute TLVs */
private static final int NODE_FLAG_BITS = 1024;
}
break;
case NODE_FLAG_BITS:
- final BitSet flags = BitSet.valueOf(ByteArray.readAllBytes(value));
+ final BitArray flags = BitArray.valueOf(value, FLAGS_SIZE);
builder.setNodeFlags(new NodeFlagBits(flags.get(OVERLOAD_BIT), flags.get(ATTACHED_BIT), flags.get(EXTERNAL_BIT), flags.get(ABBR_BIT)));
LOG.debug("Parsed Overload bit: {}, attached bit: {}, external bit: {}, area border router: {}.",
flags.get(OVERLOAD_BIT), flags.get(ATTACHED_BIT), flags.get(EXTERNAL_BIT), flags.get(ABBR_BIT));
private static void serializeNodeFlagBits(final NodeFlagBits nodeFlagBits, final ByteBuf byteAggregator) {
if (nodeFlagBits != null) {
final ByteBuf nodeFlagBuf = Unpooled.buffer(1);
- final BitSet flags = new BitSet(Byte.SIZE);
- if (nodeFlagBits.isOverload() != null) {
- flags.set(OVERLOAD_BIT, nodeFlagBits.isOverload());
- }
- if (nodeFlagBits.isAttached() != null) {
- flags.set(ATTACHED_BIT, nodeFlagBits.isAttached());
- }
- if (nodeFlagBits.isExternal() != null) {
- flags.set(EXTERNAL_BIT, nodeFlagBits.isExternal());
- }
- if (nodeFlagBits.isAbr() != null) {
- flags.set(ABBR_BIT, nodeFlagBits.isAbr());
- }
- nodeFlagBuf.writeBytes(flags.toByteArray());
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(OVERLOAD_BIT, nodeFlagBits.isOverload());
+ flags.set(ATTACHED_BIT, nodeFlagBits.isAttached());
+ flags.set(EXTERNAL_BIT, nodeFlagBits.isExternal());
+ flags.set(ABBR_BIT, nodeFlagBits.isAbr());
+ flags.toByteBuf(nodeFlagBuf);
TlvUtil.writeTLV(NODE_FLAG_BITS, nodeFlagBuf, byteAggregator);
}
}
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
-import java.util.BitSet;
import java.util.List;
import java.util.Map.Entry;
import org.opendaylight.protocol.bgp.linkstate.attribute.sr.SrPrefixAttributesParser;
import org.opendaylight.protocol.bgp.linkstate.spi.TlvUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.Ipv4Util;
import org.opendaylight.protocol.util.Ipv6Util;
private static final int ROUTE_TAG_LENGTH = 4;
private static final int EXTENDED_ROUTE_TAG_LENGTH = 8;
- private static final int UP_DOWN_BIT = 7;
+
+ private static final int FLAGS_SIZE = 8;
+ private static final int UP_DOWN_BIT = 0;
/* Prefix Attribute TLVs */
private static final int IGP_FLAGS = 1152;
LOG.trace("Prefix attribute TLV {}", key);
switch (key) {
case IGP_FLAGS:
- final BitSet flags = BitSet.valueOf(ByteArray.readAllBytes(value));
+ final BitArray flags = BitArray.valueOf(value, FLAGS_SIZE);
final boolean upDownBit = flags.get(UP_DOWN_BIT);
builder.setIgpBits(new IgpBitsBuilder().setUpDown(new UpDown(upDownBit)).build());
LOG.debug("Parsed IGP flag (up/down bit) : {}", upDownBit);
static void serializePrefixAttributes(final PrefixAttributesCase prefixAttributesCase, final ByteBuf byteAggregator) {
final PrefixAttributes prefixAtrributes = prefixAttributesCase.getPrefixAttributes();
if (prefixAtrributes.getIgpBits() != null) {
- final BitSet igpBit = new BitSet();
- final Boolean bit = prefixAtrributes.getIgpBits().getUpDown().isUpDown();
- if (bit != null) {
- igpBit.set(UP_DOWN_BIT, bit);
- }
- TlvUtil.writeTLV(IGP_FLAGS, Unpooled.wrappedBuffer(igpBit.toByteArray()), byteAggregator);
+ final BitArray igpBit = new BitArray(FLAGS_SIZE);
+ igpBit.set(UP_DOWN_BIT, prefixAtrributes.getIgpBits().getUpDown().isUpDown());
+ TlvUtil.writeTLV(IGP_FLAGS, Unpooled.wrappedBuffer(igpBit.array()), byteAggregator);
}
if (prefixAtrributes.getRouteTags() != null) {
final ByteBuf routeTagsBuf = Unpooled.buffer();
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.link.state.SrAdjId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.link.state.SrAdjIdBuilder;
private static final int ISO_SYSTEM_ID_SIZE = 6;
/* Adj-SID flags */
- private static final int ADDRESS_FAMILY_FLAG = 7;
- private static final int BACKUP_FLAG = 6;
- private static final int VALUE_FLAG = 5;
- private static final int LOCAL_FLAG = 4;
- private static final int SET_FLAG = 3;
- private static final int FLAGS_SIZE = 1;
+ private static final int ADDRESS_FAMILY_FLAG = 0;
+ private static final int BACKUP_FLAG = 1;
+ private static final int VALUE_FLAG = 2;
+ private static final int LOCAL_FLAG = 3;
+ private static final int SET_FLAG = 4;
+ private static final int FLAGS_SIZE = 8;
private SrLinkAttributesParser() {
throw new UnsupportedOperationException();
return new SrAdjIdBuilder().build();
}
final SrAdjIdBuilder srAdjIdBuilder = new SrAdjIdBuilder();
- final BitSet flags = BitSet.valueOf(ByteArray.readBytes(buffer, FLAGS_SIZE));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
srAdjIdBuilder.setFlags(new AdjacencyFlags(flags.get(ADDRESS_FAMILY_FLAG), flags.get(BACKUP_FLAG), flags.get(LOCAL_FLAG), flags.get(SET_FLAG), flags.get(VALUE_FLAG)));
srAdjIdBuilder.setWeight(new Weight(buffer.readUnsignedByte()));
srAdjIdBuilder.setSid(new SidLabel(ByteArray.readAllBytes(buffer)));
public static ByteBuf serializeAdjacencySegmentIdentifier(final SrAdjId srAdjId) {
final ByteBuf value = Unpooled.buffer();
final AdjacencyFlags srAdjIdFlags = srAdjId.getFlags();
- final BitSet flags = new BitSet(FLAGS_SIZE);
- if (srAdjIdFlags.isAddressFamily() != null) {
- flags.set(ADDRESS_FAMILY_FLAG, srAdjIdFlags.isAddressFamily());
- }
- if (srAdjIdFlags.isBackup() != null) {
- flags.set(BACKUP_FLAG, srAdjIdFlags.isBackup());
- }
- if (srAdjIdFlags.isValue() != null) {
- flags.set(VALUE_FLAG, srAdjIdFlags.isValue());
- }
- if (srAdjIdFlags.isLocal() != null) {
- flags.set(LOCAL_FLAG, srAdjIdFlags.isLocal());
- }
- if (srAdjIdFlags.isSetFlag() != null) {
- flags.set(SET_FLAG, srAdjIdFlags.isSetFlag());
- }
- value.writeBytes(flags.toByteArray());
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(ADDRESS_FAMILY_FLAG, srAdjIdFlags.isAddressFamily());
+ flags.set(BACKUP_FLAG, srAdjIdFlags.isBackup());
+ flags.set(VALUE_FLAG, srAdjIdFlags.isValue());
+ flags.set(LOCAL_FLAG, srAdjIdFlags.isLocal());
+ flags.set(SET_FLAG, srAdjIdFlags.isSetFlag());
+ flags.toByteBuf(value);
value.writeByte(srAdjId.getWeight().getValue());
value.writeBytes(srAdjId.getSid().getValue());
return value;
return new SrLanAdjIdBuilder().build();
}
final SrLanAdjIdBuilder srLanAdjIdBuilder = new SrLanAdjIdBuilder();
- final BitSet flags = BitSet.valueOf(ByteArray.readBytes(buffer, FLAGS_SIZE));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
srLanAdjIdBuilder.setFlags(new AdjacencyFlags(flags.get(ADDRESS_FAMILY_FLAG), flags.get(BACKUP_FLAG), flags.get(LOCAL_FLAG), flags.get(SET_FLAG), flags.get(VALUE_FLAG)));
srLanAdjIdBuilder.setWeight(new Weight(buffer.readUnsignedByte()));
srLanAdjIdBuilder.setIsoSystemId(new IsoSystemIdentifier(ByteArray.readBytes(buffer, ISO_SYSTEM_ID_SIZE)));
public static ByteBuf serializeLanAdjacencySegmentIdentifier(final SrLanAdjId srLanAdjId) {
final ByteBuf value = Unpooled.buffer();
final AdjacencyFlags srAdjIdFlags = srLanAdjId.getFlags();
- final BitSet flags = new BitSet(FLAGS_SIZE);
- if (srAdjIdFlags.isAddressFamily() != null) {
- flags.set(ADDRESS_FAMILY_FLAG, srAdjIdFlags.isAddressFamily());
- }
- if (srAdjIdFlags.isBackup() != null) {
- flags.set(BACKUP_FLAG, srAdjIdFlags.isBackup());
- }
- if (srAdjIdFlags.isValue() != null) {
- flags.set(VALUE_FLAG, srAdjIdFlags.isValue());
- }
- if (srAdjIdFlags.isLocal() != null) {
- flags.set(LOCAL_FLAG, srAdjIdFlags.isLocal());
- }
- if (srAdjIdFlags.isSetFlag() != null) {
- flags.set(SET_FLAG, srAdjIdFlags.isSetFlag());
- }
- value.writeBytes(flags.toByteArray());
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(ADDRESS_FAMILY_FLAG, srAdjIdFlags.isAddressFamily());
+ flags.set(BACKUP_FLAG, srAdjIdFlags.isBackup());
+ flags.set(VALUE_FLAG, srAdjIdFlags.isValue());
+ flags.set(LOCAL_FLAG, srAdjIdFlags.isLocal());
+ flags.set(SET_FLAG, srAdjIdFlags.isSetFlag());
+ flags.toByteBuf(value);
value.writeByte(srLanAdjId.getWeight().getValue());
value.writeBytes(srLanAdjId.getIsoSystemId().getValue());
value.writeBytes(srLanAdjId.getSid().getValue());
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
-import java.util.BitSet;
import java.util.List;
import org.opendaylight.protocol.bgp.linkstate.spi.TlvUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.protocol.util.Ipv4Util;
throw new UnsupportedOperationException();
}
- private static final int FLAGS_SIZE = 1;
+ private static final int FLAGS_SIZE = 8;
/* SR Capabilities flags */
- private static final int IPV4 = 7;
- private static final int IPV6 = 6;
+ private static final int IPV4 = 0;
+ private static final int IPV6 = 1;
/* SID Label flags */
- private static final int AFI = 7;
- private static final int MIRROR = 6;
+ private static final int AFI = 0;
+ private static final int MIRROR = 1;
/* SID Label Tlv types */
private static final int SID_TLV_TYPE = 1;
public static SrSidLabel parseSidLabelBinding(final ByteBuf buffer) {
final SrSidLabelBuilder builder = new SrSidLabelBuilder();
- final BitSet flags = BitSet.valueOf(ByteArray.readBytes(buffer, FLAGS_SIZE));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
builder.setSidLabelFlags(new SidLabelFlags(flags.get(AFI), flags.get(MIRROR)));
builder.setWeight(new Weight(buffer.readUnsignedByte()));
builder.setValueRange(buffer.readUnsignedShort());
public static void serializeSidLabelBinding(final SrSidLabel binding, final ByteBuf buffer) {
final SidLabelFlags flags = binding.getSidLabelFlags();
- final BitSet bs = new BitSet(FLAGS_SIZE);
- if (flags.isAddressFamily() != null) {
- bs.set(AFI, flags.isAddressFamily());
- }
- if (flags.isMirrorContext() != null) {
- bs.set(MIRROR, flags.isMirrorContext());
- }
- buffer.writeBytes(bs.toByteArray());
+ final BitArray bs = new BitArray(FLAGS_SIZE);
+ bs.set(AFI, flags.isAddressFamily());
+ bs.set(MIRROR, flags.isMirrorContext());
+ bs.toByteBuf(buffer);
buffer.writeByte(binding.getWeight().getValue());
buffer.writeShort(binding.getValueRange());
final IpPrefix prefix = binding.getFecPrefix();
public static SrCapabilities parseSrCapabilities(final ByteBuf buffer) {
final SrCapabilitiesBuilder builder = new SrCapabilitiesBuilder();
- final BitSet flags = BitSet.valueOf(ByteArray.readBytes(buffer, FLAGS_SIZE));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
builder.setFlags(new Flags(flags.get(IPV4), flags.get(IPV6)));
builder.setValueRange((long)buffer.readUnsignedMedium());
buffer.skipBytes(2);
public static void serializeSrCapabilities(final SrCapabilities caps, final ByteBuf buffer) {
final Flags flags = caps.getFlags();
- final BitSet bs = new BitSet(FLAGS_SIZE);
- if (flags.isIpv4() != null) {
- bs.set(IPV4, flags.isIpv4());
- }
- if (flags.isIpv6() != null) {
- bs.set(IPV6, flags.isIpv6());
- }
- buffer.writeBytes(bs.toByteArray());
+ final BitArray bs = new BitArray(FLAGS_SIZE);
+ bs.set(IPV4, flags.isIpv4());
+ bs.set(IPV6, flags.isIpv6());
+ bs.toByteBuf(buffer);
buffer.writeMedium(caps.getValueRange().intValue());
buffer.writeByte(SID_TLV_TYPE);
final byte[] sid = caps.getSid().getValue();
package org.opendaylight.protocol.bgp.linkstate.attribute.sr;
import io.netty.buffer.ByteBuf;
-import java.util.BitSet;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.prefix.state.SrPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev150210.prefix.state.SrPrefixBuilder;
public final class SrPrefixAttributesParser {
- private static final int FLAGS_SIZE = 1;
+ private static final int FLAGS_SIZE = 8;
private SrPrefixAttributesParser() {
throw new UnsupportedOperationException();
}
/* Flags */
- private static final int RE_ADVERTISEMENT = 7;
- private static final int NODE_SID = 6;
- private static final int NO_PHP = 5;
- private static final int EXPLICIT_NULL = 4;
- private static final int VALUE = 3;
- private static final int LOCAL = 2;
+ private static final int RE_ADVERTISEMENT = 0;
+ private static final int NODE_SID = 1;
+ private static final int NO_PHP = 2;
+ private static final int EXPLICIT_NULL = 3;
+ private static final int VALUE = 4;
+ private static final int LOCAL = 5;
public static SrPrefix parseSrPrefix(final ByteBuf buffer) {
- final BitSet flags = BitSet.valueOf(ByteArray.readBytes(buffer, FLAGS_SIZE));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
final SrPrefixBuilder builder = new SrPrefixBuilder();
builder.setFlags(new Flags(flags.get(EXPLICIT_NULL), flags.get(LOCAL), flags.get(NO_PHP), flags.get(NODE_SID), flags.get(RE_ADVERTISEMENT), flags.get(VALUE)));
builder.setAlgorithm(Algorithm.forValue(buffer.readUnsignedByte()));
public static void serializeSrPrefix(final SrPrefix srPrefix, final ByteBuf buffer) {
final Flags flags = srPrefix.getFlags();
- final BitSet bs = new BitSet(FLAGS_SIZE);
- if (flags.isReadvertisement() != null) {
- bs.set(RE_ADVERTISEMENT, flags.isReadvertisement());
- }
- if (flags.isNodeSid() != null) {
- bs.set(NODE_SID, flags.isNodeSid());
- }
- if (flags.isNoPhp() != null) {
- bs.set(NO_PHP, flags.isNoPhp());
- }
- if (flags.isExplicitNull() != null) {
- bs.set(EXPLICIT_NULL, flags.isExplicitNull());
- }
- if (flags.isValue() != null) {
- bs.set(VALUE, flags.isValue());
- }
- if (flags.isLocal() != null) {
- bs.set(LOCAL, flags.isLocal());
- }
- buffer.writeBytes(bs.toByteArray());
+ final BitArray bs = new BitArray(FLAGS_SIZE);
+ bs.set(RE_ADVERTISEMENT, flags.isReadvertisement());
+ bs.set(NODE_SID, flags.isNodeSid());
+ bs.set(NO_PHP, flags.isNoPhp());
+ bs.set(EXPLICIT_NULL, flags.isExplicitNull());
+ bs.set(VALUE, flags.isValue());
+ bs.set(LOCAL, flags.isLocal());
+ bs.toByteBuf(buffer);
buffer.writeByte(srPrefix.getAlgorithm().getIntValue());
buffer.writeBytes(srPrefix.getSid().getValue());
}
import org.opendaylight.protocol.bgp.parser.spi.AttributeSerializer;
import org.opendaylight.protocol.concepts.AbstractRegistration;
import org.opendaylight.protocol.concepts.HandlerRegistry;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.Values;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.update.PathAttributes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.update.PathAttributesBuilder;
}
private void addAttribute(final ByteBuf buffer, final Map<Integer, RawAttribute> attributes) throws BGPDocumentedException {
- final boolean[] flags = ByteArray.parseBits(buffer.readByte());
+ final BitArray flags = BitArray.valueOf(buffer.readByte());
final int type = buffer.readUnsignedByte();
- final int len = (flags[EXTENDED_LENGTH_BIT]) ? buffer.readUnsignedShort() : buffer.readUnsignedByte();
+ final int len = (flags.get(EXTENDED_LENGTH_BIT)) ? buffer.readUnsignedShort() : buffer.readUnsignedByte();
if (!attributes.containsKey(type)) {
final AttributeParser parser = this.handlers.getParser(type);
if (parser == null) {
- if (!flags[OPTIONAL_BIT]) {
+ if (!flags.get(OPTIONAL_BIT)) {
throw new BGPDocumentedException("Well known attribute not recognized.", BGPError.WELL_KNOWN_ATTR_NOT_RECOGNIZED);
}
- if (flags[TRANSITIVE_BIT]) {
+ if (flags.get(TRANSITIVE_BIT)) {
// FIXME: transitive attributes need to be preserved
LOG.warn("Losing unrecognized transitive attribute {}. Some data might be missing from the output.", type);
} else {
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.ietf.stateful07.Stateful07LspObjectParser;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvRegistry;
import org.opendaylight.protocol.pcep.spi.VendorInformationTlvRegistry;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Lsp1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Lsp1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.OperationalStatus;
*/
public class CInitiated00LspObjectParser extends Stateful07LspObjectParser {
- private static final int CREATE_FLAG_OFFSET = 8;
+ private static final int CREATE_FLAG_OFFSET = 4;
public CInitiated00LspObjectParser(final TlvRegistry tlvReg, final VendorInformationTlvRegistry viTlvReg) {
super(tlvReg, viTlvReg);
builder.setIgnore(header.isIgnore());
builder.setProcessingRule(header.isProcessingRule());
final int[] plspIdRaw = new int[] { bytes.readUnsignedByte(), bytes.readUnsignedByte(), bytes.getUnsignedByte(2), };
- builder.setPlspId(new PlspId((long) ((plspIdRaw[0] << TWELVE_BITS_SHIFT) | (plspIdRaw[1] << FOUR_BITS_SHIFT) | (plspIdRaw[2] >> FOUR_BITS_SHIFT))));
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(bytes, 2));
- builder.setDelegate(flags.get(DELEGATE_FLAG_OFFSET));
- builder.setSync(flags.get(SYNC_FLAG_OFFSET));
- builder.setRemove(flags.get(REMOVE_FLAG_OFFSET));
- builder.setAdministrative(flags.get(ADMINISTRATIVE_FLAG_OFFSET));
+ builder.setPlspId(new PlspId((long) ((plspIdRaw[0] << FLAGS_SIZE) | (plspIdRaw[1] << FOUR_BITS_SHIFT) | (plspIdRaw[2] >> FOUR_BITS_SHIFT))));
+ final BitArray flags = BitArray.valueOf(bytes, FLAGS_SIZE);
+ builder.setDelegate(flags.get(DELEGATE));
+ builder.setSync(flags.get(SYNC));
+ builder.setRemove(flags.get(REMOVE));
+ builder.setAdministrative(flags.get(ADMINISTRATIVE));
builder.addAugmentation(Lsp1.class, new Lsp1Builder().setCreate(flags.get(CREATE_FLAG_OFFSET)).build());
short s = 0;
- s |= flags.get(OPERATIONAL_OFFSET + 2) ? 1 : 0;
- s |= (flags.get(OPERATIONAL_OFFSET + 1) ? 1 : 0) << 1;
- s |= (flags.get(OPERATIONAL_OFFSET) ? 1 : 0) << 2;
+ s |= flags.get(OPERATIONAL + 2) ? 1 : 0;
+ s |= (flags.get(OPERATIONAL + 1) ? 1 : 0) << 1;
+ s |= (flags.get(OPERATIONAL) ? 1 : 0) << 2;
builder.setOperational(OperationalStatus.forValue(s));
final TlvsBuilder b = new TlvsBuilder();
parseTlvs(b, bytes.slice());
final ByteBuf body = Unpooled.buffer();
Preconditions.checkArgument(specObj.getPlspId() != null, "PLSP-ID not present");
writeMedium(specObj.getPlspId().getValue().intValue() << FOUR_BITS_SHIFT, body);
- final BitSet flags = new BitSet(2 * Byte.SIZE);
- if (specObj.isDelegate() != null) {
- flags.set(DELEGATE_FLAG_OFFSET, specObj.isDelegate());
- }
- if (specObj.isRemove() != null) {
- flags.set(REMOVE_FLAG_OFFSET, specObj.isRemove());
- }
- if (specObj.isSync() != null) {
- flags.set(SYNC_FLAG_OFFSET, specObj.isSync());
- }
- if (specObj.isAdministrative() != null) {
- flags.set(ADMINISTRATIVE_FLAG_OFFSET, specObj.isAdministrative());
- }
- if (specObj.getAugmentation(Lsp1.class) != null && specObj.getAugmentation(Lsp1.class).isCreate() != null) {
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(DELEGATE, specObj.isDelegate());
+ flags.set(REMOVE, specObj.isRemove());
+ flags.set(SYNC, specObj.isSync());
+ flags.set(ADMINISTRATIVE, specObj.isAdministrative());
+ if (specObj.getAugmentation(Lsp1.class) != null) {
flags.set(CREATE_FLAG_OFFSET, specObj.getAugmentation(Lsp1.class).isCreate());
}
byte op = 0;
op = UnsignedBytes.checkedCast(specObj.getOperational().getIntValue());
op = (byte) (op << FOUR_BITS_SHIFT);
}
- body.writeByte(ByteArray.bitSetToBytes(flags, 2)[1] | op);
+ final byte[] res = flags.array();
+ res[res.length -1] = (byte) (res[res.length -1] | op);
+ body.writeByte(res[res.length -1]);
serializeTlvs(specObj.getTlvs(), body);
ObjectUtil.formatSubobject(TYPE, CLASS, object.isProcessingRule(), object.isIgnore(), body, buffer);
}
*/
package org.opendaylight.protocol.pcep.ietf.initiated00;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedInt;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.ietf.stateful07.Stateful07SrpObjectParser;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvRegistry;
import org.opendaylight.protocol.pcep.spi.VendorInformationTlvRegistry;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Srp1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Srp1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.SrpIdNumber;
final SrpBuilder builder = new SrpBuilder();
builder.setIgnore(header.isIgnore());
builder.setProcessingRule(header.isProcessingRule());
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(bytes, FLAGS_SIZE));
+ final BitArray flags = BitArray.valueOf(bytes, FLAGS_SIZE);
builder.addAugmentation(Srp1.class, new Srp1Builder().setRemove(flags.get(REMOVE_FLAG)).build());
builder.setOperationId(new SrpIdNumber(bytes.readUnsignedInt()));
final TlvsBuilder tlvsBuilder = new TlvsBuilder();
Preconditions.checkArgument(object instanceof Srp, "Wrong instance of PCEPObject. Passed %s. Needed SrpObject.", object.getClass());
final Srp srp = (Srp) object;
final ByteBuf body = Unpooled.buffer();
- final BitSet flags = new BitSet(FLAGS_SIZE * Byte.SIZE);
- if (srp.getAugmentation(Srp1.class) != null && srp.getAugmentation(Srp1.class).isRemove()) {
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ if (srp.getAugmentation(Srp1.class) != null) {
flags.set(REMOVE_FLAG, srp.getAugmentation(Srp1.class).isRemove());
}
- writeBitSet(flags, FLAGS_SIZE, body);
+ flags.toByteBuf(body);
Preconditions.checkArgument(srp.getOperationId() != null, "OperationId is mandatory.");
writeUnsignedInt(srp.getOperationId().getValue(), body);
serializeTlvs(srp.getTlvs(), body);
*/
package org.opendaylight.protocol.pcep.ietf.initiated00;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
-
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.ietf.stateful07.Stateful07StatefulCapabilityTlvParser;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvUtil;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Stateful1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Stateful1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.stateful.capability.tlv.Stateful;
if (buffer == null) {
return null;
}
- if (buffer.readableBytes() < FLAGS_F_LENGTH) {
+ if (buffer.readableBytes() < FLAGS_F_LENGTH / Byte.SIZE) {
throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + "; Expected: >= "
- + FLAGS_F_LENGTH + ".");
+ + FLAGS_F_LENGTH / Byte.SIZE + ".");
}
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, FLAGS_F_LENGTH));
-
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_F_LENGTH);
final StatefulBuilder sb = new StatefulBuilder();
sb.setLspUpdateCapability(flags.get(U_FLAG_OFFSET));
-
if (flags.get(I_FLAG_OFFSET)) {
sb.addAugmentation(Stateful1.class, new Stateful1Builder().setInitiation(Boolean.TRUE).build());
}
public void serializeTlv(final Tlv tlv, final ByteBuf buffer) {
Preconditions.checkArgument(tlv instanceof Stateful, "StatefulCapabilityTlv is mandatory.");
final Stateful sct = (Stateful) tlv;
- final ByteBuf body = Unpooled.buffer();
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
+ final BitArray flags = new BitArray(FLAGS_F_LENGTH);
final Stateful1 sfi = sct.getAugmentation(Stateful1.class);
if (sfi != null) {
flags.set(I_FLAG_OFFSET, sfi.isInitiation());
}
- if (sct.isLspUpdateCapability() != null) {
- flags.set(U_FLAG_OFFSET, sct.isLspUpdateCapability());
- }
- writeBitSet(flags, FLAGS_F_LENGTH, body);
- TlvUtil.formatTlv(TYPE, body, buffer);
+ flags.set(U_FLAG_OFFSET, sct.isLspUpdateCapability());
+ TlvUtil.formatTlv(TYPE, Unpooled.wrappedBuffer(flags.array()), buffer);
}
}
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractObjectWithTlvsParser;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvRegistry;
import org.opendaylight.protocol.pcep.spi.VendorInformationTlvRegistry;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.OperationalStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.PlspId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.lsp.error.code.tlv.LspErrorCode;
public static final int TYPE = 1;
- /*
- * offset of TLVs offset of other fields are not defined as constants
- * because of non-standard mapping of bits
- */
- protected static final int TLVS_OFFSET = 4;
-
/*
* 12b extended to 16b so first 4b are restricted (belongs to LSP ID)
*/
- protected static final int DELEGATE_FLAG_OFFSET = 15;
- protected static final int SYNC_FLAG_OFFSET = 14;
- protected static final int REMOVE_FLAG_OFFSET = 13;
- protected static final int ADMINISTRATIVE_FLAG_OFFSET = 12;
- protected static final int OPERATIONAL_OFFSET = 9;
+ protected static final int DELEGATE = 11;
+ protected static final int SYNC = 10;
+ protected static final int REMOVE = 9;
+ protected static final int ADMINISTRATIVE = 8;
+ protected static final int OPERATIONAL = 5;
protected static final int FOUR_BITS_SHIFT = 4;
- protected static final int TWELVE_BITS_SHIFT = 12;
- protected static final int BODY_LENGTH = 4;
- protected static final int FLAGS_INDEX = 3;
- protected static final int OP_VALUE_BITS_OFFSET = 7;
+ protected static final int FLAGS_SIZE = 12;
public Stateful07LspObjectParser(final TlvRegistry tlvReg, final VendorInformationTlvRegistry viTlvReg) {
super(tlvReg, viTlvReg);
builder.setIgnore(header.isIgnore());
builder.setProcessingRule(header.isProcessingRule());
final int[] plspIdRaw = new int[] { bytes.readUnsignedByte(), bytes.readUnsignedByte(), bytes.getUnsignedByte(2), };
- builder.setPlspId(new PlspId((long) ((plspIdRaw[0] << TWELVE_BITS_SHIFT) | (plspIdRaw[1] << FOUR_BITS_SHIFT) | (plspIdRaw[2] >> FOUR_BITS_SHIFT))));
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(bytes, 2));
- builder.setDelegate(flags.get(DELEGATE_FLAG_OFFSET));
- builder.setSync(flags.get(SYNC_FLAG_OFFSET));
- builder.setRemove(flags.get(REMOVE_FLAG_OFFSET));
- builder.setAdministrative(flags.get(ADMINISTRATIVE_FLAG_OFFSET));
+ builder.setPlspId(new PlspId((long) ((plspIdRaw[0] << FLAGS_SIZE) | (plspIdRaw[1] << FOUR_BITS_SHIFT) | (plspIdRaw[2] >> FOUR_BITS_SHIFT))));
+ final BitArray flags = BitArray.valueOf(bytes, FLAGS_SIZE);
+ builder.setDelegate(flags.get(DELEGATE));
+ builder.setSync(flags.get(SYNC));
+ builder.setRemove(flags.get(REMOVE));
+ builder.setAdministrative(flags.get(ADMINISTRATIVE));
short s = 0;
- s |= flags.get(OPERATIONAL_OFFSET + 2) ? 1 : 0;
- s |= (flags.get(OPERATIONAL_OFFSET + 1) ? 1 : 0) << 1;
- s |= (flags.get(OPERATIONAL_OFFSET) ? 1 : 0) << 2;
+ s |= flags.get(OPERATIONAL + 2) ? 1 : 0;
+ s |= (flags.get(OPERATIONAL + 1) ? 1 : 0) << 1;
+ s |= (flags.get(OPERATIONAL) ? 1 : 0) << 2;
builder.setOperational(OperationalStatus.forValue(s));
final TlvsBuilder b = new TlvsBuilder();
parseTlvs(b, bytes.slice());
final ByteBuf body = Unpooled.buffer();
Preconditions.checkArgument(specObj.getPlspId() != null, "PLSP-ID not present");
writeMedium(specObj.getPlspId().getValue().intValue() << FOUR_BITS_SHIFT, body);
- final BitSet flags = new BitSet(2 * Byte.SIZE);
- if (specObj.isDelegate() != null) {
- flags.set(DELEGATE_FLAG_OFFSET, specObj.isDelegate());
- }
- if (specObj.isRemove() != null) {
- flags.set(REMOVE_FLAG_OFFSET, specObj.isRemove());
- }
- if (specObj.isSync() != null) {
- flags.set(SYNC_FLAG_OFFSET, specObj.isSync());
- }
- if (specObj.isAdministrative() != null) {
- flags.set(ADMINISTRATIVE_FLAG_OFFSET, specObj.isAdministrative());
- }
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(DELEGATE, specObj.isDelegate());
+ flags.set(REMOVE, specObj.isRemove());
+ flags.set(SYNC, specObj.isSync());
+ flags.set(ADMINISTRATIVE, specObj.isAdministrative());
byte op = 0;
if (specObj.getOperational() != null) {
op = UnsignedBytes.checkedCast(specObj.getOperational().getIntValue());
op = (byte) (op << FOUR_BITS_SHIFT);
}
- body.writeByte(ByteArray.bitSetToBytes(flags, 2)[1] | op);
+ final byte[] res = flags.array();
+ res[res.length -1] = (byte) (res[res.length -1] | op);
+ body.writeByte(res[res.length -1]);
serializeTlvs(specObj.getTlvs(), body);
ObjectUtil.formatSubobject(TYPE, CLASS, object.isProcessingRule(), object.isIgnore(), body, buffer);
}
*/
package org.opendaylight.protocol.pcep.ietf.stateful07;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv4Address;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv6Address;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvParser;
import org.opendaylight.protocol.pcep.spi.TlvSerializer;
import org.opendaylight.protocol.pcep.spi.TlvUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.Ipv4Util;
import org.opendaylight.protocol.util.Ipv6Util;
public static final int TYPE = 21;
- private static final int FLAGS_F_LENGTH = 1;
+ private static final int FLAGS_SIZE = 8;
private static final int HEADER_LENGTH = 4;
private static final int RSVP_ERROR_CLASS_NUM = 6;
private static final int USER_ERROR_CLASS_NUM = 194;
private static final int USER_ERROR_CLASS_TYPE = 1;
- private static final int IN_PLACE_FLAG_OFFSET = 7;
- private static final int NOT_GUILTY_FLAGS_OFFSET = 6;
+ private static final int IN_PLACE = 7;
+ private static final int NOT_GUILTY = 6;
@Override
public RsvpErrorSpec parseTlv(final ByteBuf buffer) throws PCEPDeserializerException {
} else if (classType == RSVP_IPV6_ERROR_CLASS_TYPE) {
builder.setNode(new IpAddress(Ipv6Util.addressForByteBuf(buffer)));
}
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, FLAGS_F_LENGTH));
- builder.setFlags(new Flags(flags.get(IN_PLACE_FLAG_OFFSET), flags.get(NOT_GUILTY_FLAGS_OFFSET)));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
+ builder.setFlags(new Flags(flags.get(IN_PLACE), flags.get(NOT_GUILTY)));
final short errorCode = buffer.readUnsignedByte();
builder.setCode(errorCode);
final int errorValue = buffer.readUnsignedShort();
}
private void serializeRsvp(final RsvpError rsvp, final ByteBuf body) {
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- flags.set(IN_PLACE_FLAG_OFFSET, rsvp.getFlags().isInPlace());
- flags.set(NOT_GUILTY_FLAGS_OFFSET, rsvp.getFlags().isNotGuilty());
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(IN_PLACE, rsvp.getFlags().isInPlace());
+ flags.set(NOT_GUILTY, rsvp.getFlags().isNotGuilty());
final IpAddress node = rsvp.getNode();
Preconditions.checkArgument(node != null, "Node is mandatory.");
final ByteBuf rsvpObjBuf = Unpooled.buffer();
type = RSVP_IPV6_ERROR_CLASS_TYPE;
writeIpv6Address(node.getIpv6Address(), rsvpObjBuf);
}
- writeBitSet(flags, FLAGS_F_LENGTH, rsvpObjBuf);
+ flags.toByteBuf(rsvpObjBuf);
Preconditions.checkArgument(rsvp.getCode() != null, "Code is mandatory.");
writeUnsignedByte(rsvp.getCode(), rsvpObjBuf);
Preconditions.checkArgument(rsvp.getValue() != null, "Value is mandatory.");
public static final int TYPE = 1;
- protected static final int FLAGS_SIZE = 4;
+ protected static final int FLAGS_SIZE = 32;
protected static final int SRP_ID_SIZE = 4;
- protected static final int TLVS_OFFSET = FLAGS_SIZE + SRP_ID_SIZE;
-
- protected static final int MIN_SIZE = FLAGS_SIZE + SRP_ID_SIZE;
+ protected static final int MIN_SIZE = FLAGS_SIZE / Byte.SIZE + SRP_ID_SIZE;
protected Stateful07SrpObjectParser(final TlvRegistry tlvReg, final VendorInformationTlvRegistry viTlvReg) {
super(tlvReg, viTlvReg);
final SrpBuilder builder = new SrpBuilder();
builder.setIgnore(header.isIgnore());
builder.setProcessingRule(header.isProcessingRule());
- bytes.skipBytes(FLAGS_SIZE);
+ bytes.skipBytes(FLAGS_SIZE / Byte.SIZE);
builder.setOperationId(new SrpIdNumber(bytes.readUnsignedInt()));
final TlvsBuilder tlvsBuilder = new TlvsBuilder();
parseTlvs(tlvsBuilder, bytes.slice());
Preconditions.checkArgument(object instanceof Srp, "Wrong instance of PCEPObject. Passed %s . Needed SrpObject.", object.getClass());
final Srp srp = (Srp) object;
final ByteBuf body = Unpooled.buffer();
- body.writerIndex(body.writerIndex() + FLAGS_SIZE);
+ body.writeZero(FLAGS_SIZE / Byte.SIZE);
final SrpIdNumber srpId = srp.getOperationId();
Preconditions.checkArgument(srpId != null, "SrpId is mandatory.");
writeUnsignedInt(srpId.getValue(), body);
*/
package org.opendaylight.protocol.pcep.ietf.stateful07;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
-
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvParser;
import org.opendaylight.protocol.pcep.spi.TlvSerializer;
import org.opendaylight.protocol.pcep.spi.TlvUtil;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.stateful.capability.tlv.Stateful;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.stateful.capability.tlv.StatefulBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
public static final int TYPE = 16;
- protected static final int FLAGS_F_LENGTH = 4;
+ protected static final int FLAGS_F_LENGTH = 32;
protected static final int U_FLAG_OFFSET = 31;
if (buffer == null) {
return null;
}
- if (buffer.readableBytes() < FLAGS_F_LENGTH) {
+ if (buffer.readableBytes() < FLAGS_F_LENGTH / Byte.SIZE) {
throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + "; Expected: >= "
- + FLAGS_F_LENGTH + ".");
+ + FLAGS_F_LENGTH / Byte.SIZE + ".");
}
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, FLAGS_F_LENGTH));
-
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_F_LENGTH);
final StatefulBuilder sb = new StatefulBuilder();
sb.setLspUpdateCapability(flags.get(U_FLAG_OFFSET));
return sb.build();
public void serializeTlv(final Tlv tlv, final ByteBuf buffer) {
Preconditions.checkArgument(tlv instanceof Stateful, "StatefulCapabilityTlv is mandatory.");
final Stateful sct = (Stateful) tlv;
- final ByteBuf body = Unpooled.buffer();
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- if (sct.isLspUpdateCapability() != null) {
- flags.set(U_FLAG_OFFSET, sct.isLspUpdateCapability());
- }
- writeBitSet(flags, FLAGS_F_LENGTH, body);
- TlvUtil.formatTlv(TYPE, body, buffer);
+ final BitArray flags = new BitArray(FLAGS_F_LENGTH);
+ flags.set(U_FLAG_OFFSET, sct.isLspUpdateCapability());
+ TlvUtil.formatTlv(TYPE, Unpooled.wrappedBuffer(flags.array()), buffer);
}
}
/* pst-tlv */
0x0, 0x1C, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0 };
final CInitiated00SrpObjectParser parser = new CInitiated00SrpObjectParser(this.tlvRegistry, this.viTlvRegistry);
- SrpBuilder builder = new SrpBuilder();
+ final SrpBuilder builder = new SrpBuilder();
builder.setProcessingRule(false);
builder.setIgnore(false);
builder.setOperationId(new SrpIdNumber(1L));
*/
package org.opendaylight.protocol.pcep.impl.object;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedInt;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractObjectWithTlvsParser;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvRegistry;
import org.opendaylight.protocol.pcep.spi.VendorInformationTlvRegistry;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ObjectHeader;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lspa.object.Lspa;
/*
* lengths of fields in bytes
*/
- private static final int FLAGS_F_LENGTH = 1;
+ private static final int FLAGS_SIZE = 8;
/*
* offsets of flags inside flags field in bits
builder.setSetupPriority(bytes.readUnsignedByte());
builder.setHoldPriority(bytes.readUnsignedByte());
- final BitSet flags = ByteArray.bytesToBitSet(new byte[] { bytes.readByte() });
+ final BitArray flags = BitArray.valueOf(bytes.readByte());
builder.setLocalProtectionDesired(flags.get(L_FLAG_OFFSET));
final TlvsBuilder tbuilder = new TlvsBuilder();
bytes.skipBytes(RESERVED);
writeAttributeFilter(lspaObj.getIncludeAll(), body);
writeUnsignedByte(lspaObj.getSetupPriority(), body);
writeUnsignedByte(lspaObj.getHoldPriority(), body);
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- if (lspaObj.isLocalProtectionDesired() != null) {
- flags.set(L_FLAG_OFFSET, lspaObj.isLocalProtectionDesired());
- }
- writeBitSet(flags, FLAGS_F_LENGTH, body);
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(L_FLAG_OFFSET, lspaObj.isLocalProtectionDesired());
+ flags.toByteBuf(body);
body.writeZero(RESERVED);
serializeTlvs(lspaObj.getTlvs(), body);
ObjectUtil.formatSubobject(TYPE, CLASS, object.isProcessingRule(), object.isIgnore(), body, buffer);
*/
package org.opendaylight.protocol.pcep.impl.object;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeFloat32;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.ObjectParser;
import org.opendaylight.protocol.pcep.spi.ObjectSerializer;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ieee754.rev130819.Float32;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
/*
* lengths of fields in bytes
*/
- private static final int FLAGS_F_LENGTH = 1;
+ private static final int FLAGS_SIZE = 8;
private static final int METRIC_VALUE_F_LENGTH = 4;
/*
+ ".");
}
bytes.skipBytes(RESERVED);
- final byte[] flagBytes = { bytes.readByte() };
- final BitSet flags = ByteArray.bytesToBitSet(flagBytes);
+ final BitArray flags = BitArray.valueOf(bytes.readByte());
final MetricBuilder builder = new MetricBuilder();
builder.setIgnore(header.isIgnore());
builder.setProcessingRule(header.isProcessingRule());
final Metric mObj = (Metric) object;
final ByteBuf body = Unpooled.buffer(SIZE);
body.writeZero(RESERVED);
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- if (mObj.isComputed() != null) {
- flags.set(C_FLAG_OFFSET, mObj.isComputed());
- }
- if (mObj.isBound() != null) {
- flags.set(B_FLAG_OFFSET, mObj.isBound());
- }
- writeBitSet(flags, FLAGS_F_LENGTH, body);
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(C_FLAG_OFFSET, mObj.isComputed());
+ flags.set(B_FLAG_OFFSET, mObj.isBound());
+ flags.toByteBuf(body);
Preconditions.checkArgument(mObj.getMetricType() != null, "MetricType is mandatory.");
writeUnsignedByte(mObj.getMetricType(), body);
writeFloat32(mObj.getValue(), body);
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractObjectWithTlvsParser;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvRegistry;
import org.opendaylight.protocol.pcep.spi.VendorInformationTlvRegistry;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ObjectHeader;
public static final int TYPE = 1;
- private static final int FLAGS = 3;
+ private static final int FLAGS_SIZE = 24;
private static final int RESERVED = 1;
private static final int L_FLAG_POS = 23;
private static final int G_FLAG_POS = 22;
Preconditions.checkArgument(buffer != null && buffer.isReadable(), "Array of bytes is mandatory. Can't be null or empty.");
final MonitoringBuilder builder = new MonitoringBuilder();
buffer.readBytes(RESERVED);
- final BitSet flagBits = ByteArray.bytesToBitSet(buffer.readBytes(FLAGS).array());
+ final BitArray flagBits = BitArray.valueOf(buffer, FLAGS_SIZE);
final Flags flags = new Flags(flagBits.get(G_FLAG_POS), flagBits.get(I_FLAG_POS), flagBits.get(L_FLAG_POS),
flagBits.get(C_FLAG_POS), flagBits.get(P_FLAG_POS));
builder.setFlags(flags);
final ByteBuf body = Unpooled.buffer();
body.writeZero(RESERVED);
final Flags flags = monitoring.getFlags();
- final BitSet flagBits = new BitSet(FLAGS);
+ final BitArray flagBits = new BitArray(FLAGS_SIZE);
flagBits.set(I_FLAG_POS, flags.isIncomplete());
flagBits.set(C_FLAG_POS, flags.isOverload());
flagBits.set(P_FLAG_POS, flags.isProcessingTime());
flagBits.set(G_FLAG_POS, flags.isGeneral());
flagBits.set(L_FLAG_POS, flags.isLiveness());
- ByteBufWriteUtil.writeBitSet(flagBits, FLAGS, body);
+ flagBits.toByteBuf(body);
ByteBufWriteUtil.writeUnsignedInt(monitoring.getMonitoringId(), body);
serializeTlvs(monitoring.getTlvs(), body);
ObjectUtil.formatSubobject(TYPE, CLASS, object.isProcessingRule(), object.isIgnore(), body, buffer);
*/
package org.opendaylight.protocol.pcep.impl.object;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractObjectWithTlvsParser;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvRegistry;
import org.opendaylight.protocol.pcep.spi.VendorInformationTlvRegistry;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ObjectHeader;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
/*
* lengths of fields in bytes
*/
- private static final int FLAGS_F_LENGTH = 2;
+ private static final int FLAGS_SIZE = 16;
private static final int RESERVED_F_LENGTH = 1;
/*
builder.setProcessingRule(header.isProcessingRule());
builder.setNatureOfIssue(bytes.readUnsignedByte());
- final byte[] flagsByte = ByteArray.readBytes(bytes, FLAGS_F_LENGTH);
- final BitSet flags = ByteArray.bytesToBitSet(flagsByte);
+ final BitArray flags = BitArray.valueOf(bytes, FLAGS_SIZE);
builder.setUnsatisfiedConstraints(flags.get(C_FLAG_OFFSET));
bytes.skipBytes(RESERVED_F_LENGTH);
final TlvsBuilder tlvsBuilder = new TlvsBuilder();
final ByteBuf body = Unpooled.buffer();
Preconditions.checkArgument(nPObj.getNatureOfIssue() != null, "NatureOfIssue is mandatory.");
writeUnsignedByte(nPObj.getNatureOfIssue(), body);
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- if (nPObj.isUnsatisfiedConstraints() != null) {
- flags.set(C_FLAG_OFFSET, nPObj.isUnsatisfiedConstraints());
- }
- writeBitSet(flags, FLAGS_F_LENGTH, body);
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(C_FLAG_OFFSET, nPObj.isUnsatisfiedConstraints());
+ flags.toByteBuf(body);
body.writeZero(RESERVED_F_LENGTH);
serializeTlvs(nPObj.getTlvs(), body);
ObjectUtil.formatSubobject(TYPE, CLASS, object.isProcessingRule(), object.isIgnore(), body, buffer);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.protocol.pcep.impl.object;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.INT_BYTES_LENGTH;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.ObjectParser;
import org.opendaylight.protocol.pcep.spi.ObjectSerializer;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ObjectHeader;
public static final int TYPE = 1;
private static final int RESERVED = 2;
- private static final int FLAGS = RESERVED;
+ private static final int FLAGS = 16;
private static final int COUNT_FIELDS = 5;
private static final int BODY_SIZE = RESERVED + FLAGS + COUNT_FIELDS * INT_BYTES_LENGTH;
private static final int E_FLAG_POSITION = 15;
final ProcTime procTime = (ProcTime) object;
final ByteBuf body = Unpooled.buffer(BODY_SIZE);
body.writeZero(RESERVED);
- final BitSet flagBits = new BitSet(FLAGS * Byte.SIZE);
+ final BitArray flagBits = new BitArray(FLAGS);
flagBits.set(E_FLAG_POSITION, procTime.isEstimated());
- ByteBufWriteUtil.writeBitSet(flagBits, FLAGS, body);
+ flagBits.toByteBuf(body);
ByteBufWriteUtil.writeUnsignedInt(procTime.getCurrentProcTime(), body);
ByteBufWriteUtil.writeUnsignedInt(procTime.getMinProcTime(), body);
ByteBufWriteUtil.writeUnsignedInt(procTime.getMaxProcTime(), body);
public Object parseObject(final ObjectHeader header, final ByteBuf buffer) throws PCEPDeserializerException {
Preconditions.checkArgument(buffer != null && buffer.isReadable(), "Array of bytes is mandatory. Can't be null or empty.");
final ProcTimeBuilder builder = new ProcTimeBuilder();
- buffer.readBytes(RESERVED);
- final BitSet flagBits = ByteArray.bytesToBitSet(buffer.readBytes(FLAGS).array());
+ buffer.skipBytes(RESERVED);
+ final BitArray flagBits = BitArray.valueOf(buffer, FLAGS);
builder.setEstimated(flagBits.get(E_FLAG_POSITION));
builder.setCurrentProcTime(buffer.readUnsignedInt());
builder.setMinProcTime(buffer.readUnsignedInt());
package org.opendaylight.protocol.pcep.impl.object;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedInt;
import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractObjectWithTlvsParser;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvRegistry;
import org.opendaylight.protocol.pcep.spi.VendorInformationTlvRegistry;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ObjectHeader;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.RequestId;
/*
* lengths of fields in bytes
*/
- private static final int FLAGS_PRI_MF_LENGTH = 4;
+ private static final int FLAGS_SIZE = 32;
/*
* lengths of subfields inside multi-field in bits
@Override
public Object parseObject(final ObjectHeader header, final ByteBuf bytes) throws PCEPDeserializerException {
Preconditions.checkArgument(bytes != null && bytes.isReadable(), "Array of bytes is mandatory. Can't be null or empty.");
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(bytes, FLAGS_PRI_MF_LENGTH));
+ final BitArray flags = BitArray.valueOf(bytes, FLAGS_SIZE);
final RpBuilder builder = new RpBuilder();
builder.setIgnore(header.isIgnore());
Preconditions.checkArgument(object instanceof Rp, "Wrong instance of PCEPObject. Passed %s. Needed RPObject.", object.getClass());
final ByteBuf body = Unpooled.buffer();
final Rp rpObj = (Rp) object;
- final BitSet flags = new BitSet(FLAGS_PRI_MF_LENGTH * Byte.SIZE);
- if (rpObj.isReoptimization() != null) {
- flags.set(R_FLAG_OFFSET, rpObj.isReoptimization());
- }
- if (rpObj.isBiDirectional() != null) {
- flags.set(B_FLAG_OFFSET, rpObj.isBiDirectional());
- }
- if (rpObj.isLoose() != null) {
- flags.set(O_FLAG_OFFSET, rpObj.isLoose());
- }
- if (rpObj.isMakeBeforeBreak() != null) {
- flags.set(M_FLAG_OFFSET, rpObj.isMakeBeforeBreak());
- }
- if (rpObj.isOrder() != null) {
- flags.set(D_FLAG_OFFSET, rpObj.isOrder());
- }
- if (rpObj.isPathKey() != null) {
- flags.set(P_FLAG_OFFSET, rpObj.isPathKey());
- }
- if (rpObj.isSupplyOf() != null) {
- flags.set(S_FLAG_OFFSET, rpObj.isSupplyOf());
- }
- if (rpObj.isFragmentation() != null) {
- flags.set(F_FLAG_OFFSET, rpObj.isFragmentation());
- }
- if (rpObj.isP2mp() != null) {
- flags.set(N_FLAG_OFFSET, rpObj.isP2mp());
- }
- if (rpObj.isEroCompression() != null) {
- flags.set(E_FLAG_OFFSET, rpObj.isEroCompression());
- }
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(R_FLAG_OFFSET, rpObj.isReoptimization());
+ flags.set(B_FLAG_OFFSET, rpObj.isBiDirectional());
+ flags.set(O_FLAG_OFFSET, rpObj.isLoose());
+ flags.set(M_FLAG_OFFSET, rpObj.isMakeBeforeBreak());
+ flags.set(D_FLAG_OFFSET, rpObj.isOrder());
+ flags.set(P_FLAG_OFFSET, rpObj.isPathKey());
+ flags.set(S_FLAG_OFFSET, rpObj.isSupplyOf());
+ flags.set(F_FLAG_OFFSET, rpObj.isFragmentation());
+ flags.set(N_FLAG_OFFSET, rpObj.isP2mp());
+ flags.set(E_FLAG_OFFSET, rpObj.isEroCompression());
+ final byte[] res = flags.array();
if (rpObj.getPriority() != null) {
- final byte[] p = { 0, 0, 0, UnsignedBytes.checkedCast(rpObj.getPriority().shortValue())};
- flags.or(ByteArray.bytesToBitSet(p));
+ final byte p = UnsignedBytes.checkedCast(rpObj.getPriority().shortValue());
+ res[res.length -1] = (byte) (res[res.length -1] | p);
}
- writeBitSet(flags, FLAGS_PRI_MF_LENGTH, body);
+ body.writeBytes(res);
Preconditions.checkArgument(rpObj.getRequestId() != null, "RequestId is mandatory");
writeUnsignedInt(rpObj.getRequestId().getValue(), body);
serializeTlvs(rpObj.getTlvs(), body);
*/
package org.opendaylight.protocol.pcep.impl.object;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedInt;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.ObjectParser;
import org.opendaylight.protocol.pcep.spi.ObjectSerializer;
import org.opendaylight.protocol.pcep.spi.ObjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.ObjectHeader;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.RequestId;
/*
* field lengths in bytes
*/
- private static final int FLAGS_F_LENGTH = 3;
+ private static final int FLAGS_SIZE = 24;
/*
* fields offsets in bytes
/*
* min size in bytes
*/
- private static final int MIN_SIZE = FLAGS_F_LENGTH + FLAGS_F_OFFSET;
+ private static final int MIN_SIZE = FLAGS_SIZE / Byte.SIZE + FLAGS_F_OFFSET;
@Override
public Svec parseObject(final ObjectHeader header, final ByteBuf bytes) throws PCEPDeserializerException {
+ MIN_SIZE + ".");
}
bytes.skipBytes(FLAGS_F_OFFSET);
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(bytes, FLAGS_F_LENGTH));
+ final BitArray flags = BitArray.valueOf(bytes, FLAGS_SIZE);
final List<RequestId> requestIDs = Lists.newArrayList();
while (bytes.isReadable()) {
final Svec svecObj = (Svec) object;
final ByteBuf body = Unpooled.buffer();
body.writeZero(FLAGS_F_OFFSET);
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- if (svecObj.isLinkDiverse() != null) {
- flags.set(L_FLAG_OFFSET, svecObj.isLinkDiverse());
- }
- if (svecObj.isNodeDiverse() != null) {
- flags.set(N_FLAG_OFFSET, svecObj.isNodeDiverse());
- }
- if (svecObj.isSrlgDiverse() != null) {
- flags.set(S_FLAG_OFFSET, svecObj.isSrlgDiverse());
- }
- writeBitSet(flags, FLAGS_F_LENGTH, body);
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(L_FLAG_OFFSET, svecObj.isLinkDiverse());
+ flags.set(N_FLAG_OFFSET, svecObj.isNodeDiverse());
+ flags.set(S_FLAG_OFFSET, svecObj.isSrlgDiverse());
+ flags.toByteBuf(body);
final List<RequestId> requestIDs = svecObj.getRequestsIds();
assert !(requestIDs.isEmpty()) : "Empty Svec Object - no request ids.";
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.EROSubobjectParser;
import org.opendaylight.protocol.pcep.spi.EROSubobjectSerializer;
import org.opendaylight.protocol.pcep.spi.EROSubobjectUtil;
import org.opendaylight.protocol.pcep.spi.LabelRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.ero.Subobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.ero.SubobjectBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev130820.basic.explicit.route.subobjects.subobject.type.LabelCase;
public static final int TYPE = 3;
- private static final int RES_F_LENGTH = 1;
+ private static final int FLAGS_SIZE = 8;
private static final int C_TYPE_F_LENGTH = 1;
- private static final int RES_F_OFFSET = 0;
-
- private static final int C_TYPE_F_OFFSET = RES_F_OFFSET + RES_F_LENGTH;
+ private static final int C_TYPE_F_OFFSET = FLAGS_SIZE / Byte.SIZE;
private static final int HEADER_LENGTH = C_TYPE_F_OFFSET + C_TYPE_F_LENGTH;
throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + "; Expected: >"
+ HEADER_LENGTH + ".");
}
- final BitSet reserved = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, RES_F_LENGTH));
+ final BitArray reserved = BitArray.valueOf(buffer, FLAGS_SIZE);
final short cType = buffer.readUnsignedByte();
final LabelType labelType = this.registry.parseLabel(cType, buffer.slice());
*/
package org.opendaylight.protocol.pcep.impl.subobject;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv4Prefix;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.RROSubobjectParser;
import org.opendaylight.protocol.pcep.spi.RROSubobjectSerializer;
import org.opendaylight.protocol.pcep.spi.RROSubobjectUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.Ipv4Util;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
public static final int TYPE = 1;
private static final int PREFIX_F_LENGTH = 1;
- private static final int FLAGS_F_LENGTH = 1;
+ private static final int FLAGS_SIZE = 8;
private static final int PREFIX4_F_OFFSET = 0 + Ipv4Util.IP4_LENGTH;
- private static final int CONTENT4_LENGTH = Ipv4Util.IP4_LENGTH + PREFIX_F_LENGTH + FLAGS_F_LENGTH;
+ private static final int CONTENT4_LENGTH = Ipv4Util.IP4_LENGTH + PREFIX_F_LENGTH + FLAGS_SIZE / Byte.SIZE;
private static final int LPA_F_OFFSET = 7;
private static final int LPIU_F_OFFSET = 6;
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev130820.record.route.subobjects.subobject.type.ip.prefix._case.IpPrefix prefix = new IpPrefixBuilder().setIpPrefix(
new IpPrefix(Ipv4Util.prefixForBytes(ByteArray.readBytes(buffer, Ipv4Util.IP4_LENGTH), length))).build();
buffer.skipBytes(PREFIX_F_LENGTH);
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, FLAGS_F_LENGTH));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
builder.setProtectionAvailable(flags.get(LPA_F_OFFSET));
builder.setProtectionInUse(flags.get(LPIU_F_OFFSET));
builder.setSubobjectType(new IpPrefixCaseBuilder().setIpPrefix(prefix).build());
if (prefix.getIpv6Prefix() != null) {
new RROIpv6PrefixSubobjectParser().serializeSubobject(subobject, buffer);
} else {
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- if (subobject.isProtectionAvailable() != null) {
- flags.set(LPA_F_OFFSET, subobject.isProtectionAvailable());
- }
- if (subobject.isProtectionInUse() != null) {
- flags.set(LPIU_F_OFFSET, subobject.isProtectionInUse());
- }
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(LPA_F_OFFSET, subobject.isProtectionAvailable());
+ flags.set(LPIU_F_OFFSET, subobject.isProtectionInUse());
final ByteBuf body = Unpooled.buffer(CONTENT4_LENGTH);
Preconditions.checkArgument(prefix.getIpv4Prefix() != null, "Ipv4Prefix is mandatory.");
writeIpv4Prefix(prefix.getIpv4Prefix(), body);
- writeBitSet(flags, FLAGS_F_LENGTH, body);
+ flags.toByteBuf(body);
RROSubobjectUtil.formatSubobject(TYPE, body, buffer);
}
}
*/
package org.opendaylight.protocol.pcep.impl.subobject;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv6Prefix;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.RROSubobjectParser;
import org.opendaylight.protocol.pcep.spi.RROSubobjectSerializer;
import org.opendaylight.protocol.pcep.spi.RROSubobjectUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.Ipv6Util;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
public static final int TYPE = 2;
private static final int PREFIX_F_LENGTH = 1;
- private static final int FLAGS_F_LENGTH = 1;
+ private static final int FLAGS_SIZE = 8;
private static final int PREFIX_F_OFFSET = Ipv6Util.IPV6_LENGTH;
- private static final int CONTENT_LENGTH = Ipv6Util.IPV6_LENGTH + PREFIX_F_LENGTH + FLAGS_F_LENGTH;
+ private static final int CONTENT_LENGTH = Ipv6Util.IPV6_LENGTH + PREFIX_F_LENGTH + FLAGS_SIZE / Byte.SIZE;
private static final int LPA_F_OFFSET = 7;
private static final int LPIU_F_OFFSET = 6;
final IpPrefixBuilder prefix = new IpPrefixBuilder().setIpPrefix(new IpPrefix(Ipv6Util.prefixForBytes(ByteArray.readBytes(buffer,
Ipv6Util.IPV6_LENGTH), length)));
buffer.skipBytes(PREFIX_F_LENGTH);
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, FLAGS_F_LENGTH));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
builder.setProtectionAvailable(flags.get(LPA_F_OFFSET));
builder.setProtectionInUse(flags.get(LPIU_F_OFFSET));
builder.setSubobjectType(new IpPrefixCaseBuilder().setIpPrefix(prefix.build()).build());
Preconditions.checkArgument(subobject.getSubobjectType() instanceof IpPrefixCase, "Unknown subobject instance. Passed %s. Needed IpPrefixCase.", subobject.getSubobjectType().getClass());
final IpPrefixSubobject specObj = ((IpPrefixCase) subobject.getSubobjectType()).getIpPrefix();
final IpPrefix prefix = specObj.getIpPrefix();
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- if (subobject.isProtectionAvailable() != null) {
- flags.set(LPA_F_OFFSET, subobject.isProtectionAvailable());
- }
- if (subobject.isProtectionInUse() != null) {
- flags.set(LPIU_F_OFFSET, subobject.isProtectionInUse());
- }
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(LPA_F_OFFSET, subobject.isProtectionAvailable());
+ flags.set(LPIU_F_OFFSET, subobject.isProtectionInUse());
final ByteBuf body = Unpooled.buffer(CONTENT_LENGTH);
Preconditions.checkArgument(prefix.getIpv6Prefix() != null, "Ipv6Prefix is mandatory.");
writeIpv6Prefix(prefix.getIpv6Prefix(), body);
- writeBitSet(flags, FLAGS_F_LENGTH, body);
+ flags.toByteBuf(body);
RROSubobjectUtil.formatSubobject(TYPE, body, buffer);
}
}
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.LabelRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.RROSubobjectParser;
import org.opendaylight.protocol.pcep.spi.RROSubobjectSerializer;
import org.opendaylight.protocol.pcep.spi.RROSubobjectUtil;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.rro.Subobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.rro.SubobjectBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev130820.label.subobject.LabelType;
public static final int TYPE = 3;
- public static final int RES_F_LENGTH = 1;
+ public static final int FLAGS_SIZE = 8;
public static final int C_TYPE_F_LENGTH = 1;
- public static final int RES_F_OFFSET = 0;
-
- public static final int C_TYPE_F_OFFSET = RES_F_OFFSET + RES_F_LENGTH;
+ public static final int C_TYPE_F_OFFSET = FLAGS_SIZE / Byte.SIZE;
public static final int HEADER_LENGTH = C_TYPE_F_OFFSET + C_TYPE_F_LENGTH;
throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + "; Expected: >"
+ HEADER_LENGTH + ".");
}
- final BitSet reserved = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, RES_F_LENGTH));
+ final BitArray reserved = BitArray.valueOf(buffer, FLAGS_SIZE);
final short cType = buffer.readUnsignedByte();
*/
package org.opendaylight.protocol.pcep.impl.subobject;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedInt;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.RROSubobjectParser;
import org.opendaylight.protocol.pcep.spi.RROSubobjectSerializer;
import org.opendaylight.protocol.pcep.spi.RROSubobjectUtil;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.rro.Subobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.rro.SubobjectBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev130820.UnnumberedSubobject;
public static final int TYPE = 4;
- private static final int FLAGS_F_LENGTH = 1;
+ private static final int FLAGS_SIZE = 8;
private static final int RESERVED = 1;
private static final int CONTENT_LENGTH = 10;
+ CONTENT_LENGTH + ".");
}
final SubobjectBuilder builder = new SubobjectBuilder();
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readBytes(buffer, FLAGS_F_LENGTH));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
builder.setProtectionAvailable(flags.get(LPA_F_OFFSET));
builder.setProtectionInUse(flags.get(LPIU_F_OFFSET));
final UnnumberedBuilder ubuilder = new UnnumberedBuilder();
public void serializeSubobject(final Subobject subobject, final ByteBuf buffer) {
Preconditions.checkArgument(subobject.getSubobjectType() instanceof UnnumberedCase, "Unknown subobject instance. Passed %s. Needed UnnumberedCase.", subobject.getSubobjectType().getClass());
final UnnumberedSubobject specObj = ((UnnumberedCase) subobject.getSubobjectType()).getUnnumbered();
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- if (subobject.isProtectionAvailable() != null) {
- flags.set(LPA_F_OFFSET, subobject.isProtectionAvailable());
- }
- if (subobject.isProtectionInUse() != null) {
- flags.set(LPIU_F_OFFSET, subobject.isProtectionInUse());
- }
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(LPA_F_OFFSET, subobject.isProtectionAvailable());
+ flags.set(LPIU_F_OFFSET, subobject.isProtectionInUse());
final ByteBuf body = Unpooled.buffer(CONTENT_LENGTH);
- writeBitSet(flags, FLAGS_F_LENGTH, body);
+ flags.toByteBuf(body);
body.writeZero(RESERVED);
Preconditions.checkArgument(specObj.getRouterId() != null, "RouterId is mandatory.");
writeUnsignedInt(specObj.getRouterId(), body);
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvParser;
import org.opendaylight.protocol.pcep.spi.TlvSerializer;
import org.opendaylight.protocol.pcep.spi.TlvUtil;
-import org.opendaylight.protocol.util.ByteArray;
-import org.opendaylight.protocol.util.ByteBufWriteUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.NoPathVectorTlv.Flags;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.failure._case.no.path.tlvs.NoPathVector;
public static final int TYPE = 1;
- private static final int FLAGS_F_LENGTH = 4;
+ private static final int FLAGS_SIZE = 32;
private static final int REACHABLITY_PROBLEM = 24;
private static final int NO_GCO_SOLUTION = 25;
if (buffer == null) {
return null;
}
- if (buffer.readableBytes() != FLAGS_F_LENGTH) {
+ if (buffer.readableBytes() != FLAGS_SIZE / Byte.SIZE) {
throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + "; Expected: >="
- + FLAGS_F_LENGTH + ".");
+ + FLAGS_SIZE / Byte.SIZE + ".");
}
- final BitSet flags = ByteArray.bytesToBitSet(ByteArray.readAllBytes(buffer));
+ final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
return new NoPathVectorBuilder().setFlags(
new Flags(flags.get(CHAIN_UNAVAILABLE), flags.get(NO_GCO_MIGRATION_PATH), flags.get(NO_GCO_SOLUTION), flags.get(REACHABLITY_PROBLEM), flags.get(PATH_KEY), flags.get(PCE_UNAVAILABLE), flags.get(UNKNOWN_DEST), flags.get(UNKNOWN_SRC))).build();
}
Preconditions.checkArgument(tlv instanceof NoPathVector, "NoPathVectorTlv is mandatory.");
final NoPathVector noPath = (NoPathVector) tlv;
final ByteBuf body = Unpooled.buffer();
- final BitSet flags = new BitSet(FLAGS_F_LENGTH * Byte.SIZE);
- Flags f = noPath.getFlags();
- if (f.isP2mpUnreachable() != null) {
- flags.set(REACHABLITY_PROBLEM, f.isP2mpUnreachable());
- }
- if (f.isNoGcoSolution() != null) {
- flags.set(NO_GCO_SOLUTION, f.isNoGcoSolution());
- }
- if (f.isNoGcoMigration() != null) {
- flags.set(NO_GCO_MIGRATION_PATH, f.isNoGcoMigration());
- }
- if (f.isPathKey() != null) {
- flags.set(PATH_KEY, f.isPathKey());
- }
- if (f.isChainUnavailable() != null) {
- flags.set(CHAIN_UNAVAILABLE, f.isChainUnavailable());
- }
- if (f.isUnknownSource() != null) {
- flags.set(UNKNOWN_SRC, f.isUnknownSource());
- }
- if (f.isUnknownDestination() != null) {
- flags.set(UNKNOWN_DEST, f.isUnknownDestination());
- }
- if (f.isPceUnavailable() != null) {
- flags.set(PCE_UNAVAILABLE, f.isPceUnavailable());
- }
- ByteBufWriteUtil.writeBitSet(flags, FLAGS_F_LENGTH, body);
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ final Flags f = noPath.getFlags();
+ flags.set(REACHABLITY_PROBLEM, f.isP2mpUnreachable());
+ flags.set(NO_GCO_SOLUTION, f.isNoGcoSolution());
+ flags.set(NO_GCO_MIGRATION_PATH, f.isNoGcoMigration());
+ flags.set(PATH_KEY, f.isPathKey());
+ flags.set(CHAIN_UNAVAILABLE, f.isChainUnavailable());
+ flags.set(UNKNOWN_SRC, f.isUnknownSource());
+ flags.set(UNKNOWN_DEST, f.isUnknownDestination());
+ flags.set(PCE_UNAVAILABLE, f.isPceUnavailable());
+ flags.toByteBuf(body);
TlvUtil.formatTlv(TYPE, body, buffer);
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.protocol.pcep.segment.routing;
import static org.opendaylight.protocol.pcep.segment.routing.SrSubobjectParserUtil.BITSET_LENGTH;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.EROSubobjectParser;
import org.opendaylight.protocol.pcep.spi.EROSubobjectSerializer;
import org.opendaylight.protocol.pcep.spi.EROSubobjectUtil;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev150112.SrEroSubobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev150112.SrSubobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev150112.add.lsp.input.arguments.ero.subobject.subobject.type.SrEroTypeBuilder;
if (srEroSubobject.isMFlag() != null && srEroSubobject.isMFlag() && srEroSubobject.getSid() != null) {
builder.setSid(srEroSubobject.getSid() << MPLS_LABEL_OFFSET);
}
-
- final BitSet bits = new BitSet(BITSET_LENGTH);
- if (srEroSubobject.isMFlag() != null) {
- bits.set(M_FLAG_POSITION, srEroSubobject.isMFlag());
- }
- if (srEroSubobject.isCFlags() != null) {
- bits.set(C_FLAG_POSITION, srEroSubobject.isCFlags());
- }
+ final BitArray bits = new BitArray(BITSET_LENGTH);
+ bits.set(M_FLAG_POSITION, srEroSubobject.isMFlag());
+ bits.set(C_FLAG_POSITION, srEroSubobject.isCFlags());
if (srEroSubobject.getSid() == null) {
- bits.set(S_FLAG_POSITION);
+ bits.set(S_FLAG_POSITION, Boolean.TRUE);
}
if (srEroSubobject.getNai() == null) {
- bits.set(F_FLAG_POSITION);
+ bits.set(F_FLAG_POSITION, Boolean.TRUE);
}
final ByteBuf body = SrSubobjectParserUtil.serializeSrSubobject(builder.build(), bits);
EROSubobjectUtil.formatSubobject(TYPE, subobject.isLoose(), body, buffer);
if (buffer.readableBytes() <= SrSubobjectParserUtil.MINIMAL_LENGTH) {
throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + ";");
}
-
- final BitSet flags = new BitSet(BITSET_LENGTH);
- final SrSubobject srSubobject = SrSubobjectParserUtil.parseSrSubobject(buffer, new Function<BitSet, Void>() {
+ final BitArray flags = new BitArray(BITSET_LENGTH);
+ final SrSubobject srSubobject = SrSubobjectParserUtil.parseSrSubobject(buffer, new Function<BitArray, Void>() {
@Override
- public Void apply(final BitSet input) {
+ public Void apply(final BitArray input) {
flags.set(C_FLAG_POSITION, input.get(C_FLAG_POSITION));
flags.set(M_FLAG_POSITION, input.get(M_FLAG_POSITION));
return null;
if (srEroSubobjectBuilder.isMFlag() != null && srEroSubobjectBuilder.isMFlag() && srEroSubobjectBuilder.getSid() != null) {
srEroSubobjectBuilder.setSid(srEroSubobjectBuilder.getSid() >> MPLS_LABEL_OFFSET);
}
-
final SubobjectBuilder subobjectBuilder = new SubobjectBuilder();
subobjectBuilder.setLoose(loose);
subobjectBuilder.setSubobjectType(srEroSubobjectBuilder.build());
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.RROSubobjectParser;
import org.opendaylight.protocol.pcep.spi.RROSubobjectSerializer;
import org.opendaylight.protocol.pcep.spi.RROSubobjectUtil;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev150112.SrRroSubobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev150112.SrSubobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev150112.add.lsp.input.arguments.rro.subobject.subobject.type.SrRroTypeBuilder;
.getClass());
final SrRroSubobject srRroSubobject = (SrRroSubobject) subobject.getSubobjectType();
- final BitSet bits = new BitSet(BITSET_LENGTH);
+ final BitArray bits = new BitArray(BITSET_LENGTH);
if (srRroSubobject.getSid() == null) {
- bits.set(S_FLAG_POSITION);
+ bits.set(S_FLAG_POSITION, Boolean.TRUE);
}
if (srRroSubobject.getNai() == null) {
- bits.set(F_FLAG_POSITION);
+ bits.set(F_FLAG_POSITION, Boolean.TRUE);
}
final ByteBuf body = SrSubobjectParserUtil.serializeSrSubobject(srRroSubobject, bits);
RROSubobjectUtil.formatSubobject(TYPE, body, buffer);
throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + ";");
}
- final SrSubobject srSubobject = SrSubobjectParserUtil.parseSrSubobject(buffer, new Function<BitSet, Void>() {
+ final SrSubobject srSubobject = SrSubobjectParserUtil.parseSrSubobject(buffer, new Function<BitArray, Void>() {
@Override
- public Void apply(final BitSet input) {
+ public Void apply(final BitArray input) {
return null;
}
}, F_FLAG_POSITION, S_FLAG_POSITION);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.protocol.pcep.segment.routing;
-import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBitSet;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv4Address;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv6Address;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import java.util.BitSet;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.protocol.util.Ipv4Util;
import org.opendaylight.protocol.util.Ipv6Util;
public static final int MINIMAL_LENGTH = 4;
public static final int BITSET_LENGTH = 8;
- private static final int FLAGS_OFFSET = 1;
private static final int SID_TYPE_BITS_OFFSET = 4;
private SrSubobjectParserUtil() {
throw new UnsupportedOperationException();
}
- public static ByteBuf serializeSrSubobject(final SrSubobject srSubobject, final BitSet bits) {
+ public static ByteBuf serializeSrSubobject(final SrSubobject srSubobject, final BitArray bits) {
Preconditions.checkArgument(srSubobject.getNai() != null || srSubobject.getSid() != null,
"Both SID and NAI are absent in SR subobject.");
final ByteBuf body = Unpooled.buffer(MINIMAL_LENGTH);
writeUnsignedByte((short)(srSubobject.getSidType().getIntValue() << SID_TYPE_BITS_OFFSET), body);
-
- writeBitSet(bits, FLAGS_OFFSET, body);
+ bits.toByteBuf(body);
if (srSubobject.getSid() != null) {
writeUnsignedInt(srSubobject.getSid(), body);
return body;
}
- public static SrSubobject parseSrSubobject(final ByteBuf buffer, final Function<BitSet, Void> getFlags, final int fPosition, final int sPosition)
+ public static SrSubobject parseSrSubobject(final ByteBuf buffer, final Function<BitArray, Void> getFlags, final int fPosition, final int sPosition)
throws PCEPDeserializerException {
final int sidTypeByte = buffer.readByte() >> SID_TYPE_BITS_OFFSET;
final SidType sidType = SidType.forValue(sidTypeByte);
- final BitSet bitSet = ByteArray.bytesToBitSet(new byte[] { buffer.readByte() });
+ final BitArray bitSet = BitArray.valueOf(buffer.readByte());
getFlags.apply(bitSet);
final boolean f = bitSet.get(fPosition);
final boolean s = bitSet.get(sPosition);
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.BitSet;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nullable;
+import org.opendaylight.protocol.util.BitArray;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.iana.rev130816.EnterpriseNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.PcerrBuilder;
private static final int COMMON_OBJECT_HEADER_LENGTH = 4;
private static final int OT_SF_LENGTH = 4;
- private static final int FLAGS_SF_LENGTH = 4;
/*
* offsets of fields inside of multi-field in bits
*/
private static final int OT_SF_OFFSET = 0;
- private static final int FLAGS_SF_OFFSET = OT_SF_OFFSET + OT_SF_LENGTH;
/*
* flags offsets inside multi-filed
*/
- private static final int P_FLAG_OFFSET = 6;
- private static final int I_FLAG_OFFSET = 7;
+ private static final int PROCESSED = 6;
+ private static final int IGNORED = 7;
private final ObjectRegistry registry;
private final VendorInformationObjectRegistry viRegistry;
final int objClass = bytes.readUnsignedByte();
final byte flagsByte = bytes.readByte();
+ final BitArray flags = BitArray.valueOf(flagsByte);
final int objType = UnsignedBytes.toInt(ByteArray.copyBitsRange(flagsByte, OT_SF_OFFSET, OT_SF_LENGTH));
- final byte[] flagsBytes = { ByteArray.copyBitsRange(flagsByte, FLAGS_SF_OFFSET, FLAGS_SF_LENGTH) };
- final BitSet flags = ByteArray.bytesToBitSet(flagsBytes);
-
final int objLength = bytes.readUnsignedShort();
if (bytes.readableBytes() < objLength - COMMON_OBJECT_HEADER_LENGTH) {
// copy bytes for deeper parsing
final ByteBuf bytesToPass = bytes.readSlice(objLength - COMMON_OBJECT_HEADER_LENGTH);
- final ObjectHeader header = new ObjectHeaderImpl(flags.get(P_FLAG_OFFSET), flags.get(I_FLAG_OFFSET));
+ final ObjectHeader header = new ObjectHeaderImpl(flags.get(PROCESSED), flags.get(IGNORED));
if (VendorInformationUtil.isVendorInformationObject(objClass, objType)) {
Preconditions.checkState(this.viRegistry != null);
package org.opendaylight.protocol.pcep.spi;
import io.netty.buffer.ByteBuf;
-import java.util.BitSet;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
public final class LabelUtil {
- private static final int RES_F_LENGTH = 1;
+ private static final int FLAGS_SIZE = 8;
- private static final int U_FLAG_OFFSET = 0;
-
- private static final int G_FLAG_OFFSET = 7;
+ private static final int UNIDIRECTIONAL = 0;
+ private static final int GLOBAL = 7;
private LabelUtil() {
throw new UnsupportedOperationException();
}
public static void formatLabel(final int type, final Boolean unidirectional, final Boolean global, final ByteBuf body, final ByteBuf buffer) {
- final BitSet reserved = new BitSet(RES_F_LENGTH * Byte.SIZE);
- if (unidirectional != null) {
- reserved.set(U_FLAG_OFFSET, unidirectional);
- }
- if (global != null) {
- reserved.set(G_FLAG_OFFSET, global);
- }
- buffer.writeBytes(ByteArray.bitSetToBytes(reserved, RES_F_LENGTH));
+ final BitArray reserved = new BitArray(FLAGS_SIZE);
+ reserved.set(UNIDIRECTIONAL, unidirectional);
+ reserved.set(GLOBAL, global);
+ reserved.toByteBuf(buffer);
buffer.writeByte(type);
buffer.writeBytes(body);
}
package org.opendaylight.protocol.pcep.spi;
import io.netty.buffer.ByteBuf;
-import java.util.BitSet;
-import org.opendaylight.protocol.util.ByteArray;
+import org.opendaylight.protocol.util.BitArray;
public final class ObjectUtil {
private static final int HEADER_SIZE = 4;
- private static final int OT_SF_LENGTH = 4;
+ private static final int FLAGS_SIZE = 4;
/*
* flags offsets inside multi-field
*/
- private static final int P_FLAG_OFFSET = 6;
- private static final int I_FLAG_OFFSET = 7;
+ private static final int PROCESSED = 2;
+ private static final int IGNORED = 3;
private ObjectUtil() {
throw new UnsupportedOperationException();
public static void formatSubobject(final int objectType, final int objectClass, final Boolean processingRule, final Boolean ignore,
final ByteBuf body, final ByteBuf out) {
out.writeByte(objectClass);
- BitSet flags = new BitSet(Byte.SIZE);
- if (ignore != null) {
- flags.set(I_FLAG_OFFSET, ignore);
- }
- if (processingRule != null) {
- flags.set(P_FLAG_OFFSET, processingRule);
- }
- byte[] flagB = ByteArray.bitSetToBytes(flags, 1);
- int typeByte = objectType << OT_SF_LENGTH | flagB[0];
+ final BitArray flags = new BitArray(FLAGS_SIZE);
+ flags.set(IGNORED, ignore);
+ flags.set(PROCESSED, processingRule);
+ final byte flagB = flags.toByte();
+ final int typeByte = objectType << FLAGS_SIZE | flagB;
out.writeByte(typeByte);
out.writeShort(body.writerIndex() + HEADER_SIZE);
out.writeBytes(body);
Code Review / bgpcep.git / commitdiff