*/
package org.opendaylight.protocol.bgp.linkstate.impl.attribute;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.writeUint32;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Multimap;
import io.netty.buffer.ByteBuf;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint8;
-import org.opendaylight.yangtools.yang.common.netty.ByteBufUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.debug("Parsed IPv6 Router-ID of remote node: {}", builder.getRemoteIpv6RouterId());
break;
case ADMIN_GROUP:
- builder.setAdminGroup(new AdministrativeGroup(ByteBufUtils.readUint32(value)));
+ builder.setAdminGroup(new AdministrativeGroup(readUint32(value)));
LOG.debug("Parsed Administrative Group {}", builder.getAdminGroup());
break;
case MAX_BANDWIDTH:
parseUnreservedBandwidth(value, builder);
break;
case TE_METRIC:
- builder.setTeMetric(new TeMetric(ByteBufUtils.readUint32(value)));
+ builder.setTeMetric(new TeMetric(readUint32(value)));
LOG.debug("Parsed Metric {}", builder.getTeMetric());
break;
case LINK_PROTECTION_TYPE:
parseSrlg(value, builder);
break;
case LINK_OPAQUE:
- LOG.debug("Parsed Opaque value : {}", ByteBufUtil.hexDump(value));
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Parsed Opaque value : {}", ByteBufUtil.hexDump(value));
+ }
break;
case LINK_NAME:
builder.setLinkName(new String(ByteArray.readAllBytes(value), StandardCharsets.US_ASCII));
break;
// Performance Metrics
case LINK_DELAY:
- builder.setLinkDelay(new Delay(ByteBufUtils.readUint32(value)));
+ builder.setLinkDelay(new Delay(readUint32(value)));
LOG.debug("Parsed Link Delay {}", builder.getLinkDelay());
break;
case LINK_MIN_MAX_DELAY:
builder.setLinkMinMaxDelay(new LinkMinMaxDelayBuilder()
- .setMinDelay(new Delay(ByteBufUtils.readUint32(value)))
- .setMaxDelay(new Delay(ByteBufUtils.readUint32(value)))
+ .setMinDelay(new Delay(readUint32(value)))
+ .setMaxDelay(new Delay(readUint32(value)))
.build());
LOG.debug("Parsed Link Min/Max Delay {}", builder.getLinkMinMaxDelay());
break;
case DELAY_VARIATION:
- builder.setDelayVariation(new Delay(ByteBufUtils.readUint32(value)));
+ builder.setDelayVariation(new Delay(readUint32(value)));
LOG.debug("Parsed Delay Variation {}", builder.getDelayVariation());
break;
case LINK_LOSS:
- builder.setLinkLoss(new Loss(ByteBufUtils.readUint32(value)));
+ builder.setLinkLoss(new Loss(readUint32(value)));
LOG.debug("Parsed Link Loss {}", builder.getLinkLoss());
break;
case RESIDUAL_BANDWIDTH:
private static void parseSrlg(final ByteBuf value, final LinkAttributesBuilder builder) {
final List<SrlgId> sharedRiskLinkGroups = new ArrayList<>();
while (value.isReadable()) {
- sharedRiskLinkGroups.add(new SrlgId(ByteBufUtils.readUint32(value)));
+ sharedRiskLinkGroups.add(new SrlgId(readUint32(value)));
}
builder.setSharedRiskLinkGroups(sharedRiskLinkGroups);
LOG.debug("Parsed Shared Risk Link Groups {}", builder.getSharedRiskLinkGroups());
if (srlgList != null) {
final ByteBuf sharedRLGBuf = Unpooled.buffer();
for (final SrlgId srlgId : srlgList) {
- sharedRLGBuf.writeInt(srlgId.getValue().intValue());
+ writeUint32(sharedRLGBuf, srlgId.getValue());
}
TlvUtil.writeTLV(SHARED_RISK_LINK_GROUP, sharedRLGBuf, byteAggregator);
}
private static void serializeLinkMinMaxDelay(final LinkMinMaxDelay linkMinMaxDelay, final ByteBuf byteAggregator) {
if (linkMinMaxDelay != null) {
- final ByteBuf linkMinMaxDelayBuf = Unpooled.buffer();
- linkMinMaxDelayBuf.writeInt(linkMinMaxDelay.getMinDelay().getValue().intValue());
- linkMinMaxDelayBuf.writeInt(linkMinMaxDelay.getMaxDelay().getValue().intValue());
+ final ByteBuf linkMinMaxDelayBuf = Unpooled.buffer(8);
+ writeUint32(linkMinMaxDelayBuf, linkMinMaxDelay.getMinDelay().getValue());
+ writeUint32(linkMinMaxDelayBuf, linkMinMaxDelay.getMaxDelay().getValue());
TlvUtil.writeTLV(LINK_MIN_MAX_DELAY, linkMinMaxDelayBuf, byteAggregator);
}
}
*/
package org.opendaylight.protocol.bgp.linkstate.impl.attribute;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.writeUint16;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Multimap;
import io.netty.buffer.ByteBuf;
if (topList != null) {
final ByteBuf mpIdBuf = Unpooled.buffer();
for (final TopologyIdentifier topologyIdentifier : topList) {
- mpIdBuf.writeShort(topologyIdentifier.getValue().toJava());
+ writeUint16(mpIdBuf, topologyIdentifier.getValue());
}
TlvUtil.writeTLV(TlvUtil.MULTI_TOPOLOGY_ID, mpIdBuf, byteAggregator);
}
*/
package org.opendaylight.protocol.bgp.linkstate.impl.attribute.sr;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.writeUint8;
+
import io.netty.buffer.ByteBuf;
import java.util.List;
import org.opendaylight.protocol.bgp.linkstate.spi.pojo.SimpleBindingSubTlvsRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.binding.sid.tlv.flags.IsisBindingFlagsCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.binding.sid.tlv.flags.OspfBindingFlagsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.binding.sid.tlv.flags.OspfBindingFlagsCaseBuilder;
-import org.opendaylight.yangtools.yang.common.netty.ByteBufUtils;
public final class BindingSidLabelParser {
/* Flags */
public static SrBindingSidLabels parseBindingSidLabel(final ByteBuf buffer, final ProtocolId protocolId) {
final SrBindingSidLabelsBuilder bindingSid = new SrBindingSidLabelsBuilder();
- bindingSid.setWeight(new Weight(ByteBufUtils.readUint8(buffer)));
+ bindingSid.setWeight(new Weight(readUint8(buffer)));
final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE);
bindingSid.setFlags(parseBindingSidFlags(flags, protocolId));
buffer.skipBytes(RESERVED_BINDING_SID);
public static void serializeBindingSidAttributes(final Weight weight, final Flags flags,
final List<BindingSubTlvs> bindingSubTlvs, final ByteBuf aggregator) {
- aggregator.writeByte(weight.getValue().toJava());
+ writeUint8(aggregator, weight.getValue());
final BitArray bitFlags = serializeBindingSidFlags(flags);
bitFlags.toByteBuf(aggregator);
aggregator.writeZero(RESERVED_BINDING_SID);
import static org.opendaylight.protocol.bgp.linkstate.impl.attribute.sr.binding.sid.sub.tlvs.Ipv4PrefixSidParser.PREFIX_SID;
import static org.opendaylight.protocol.bgp.linkstate.impl.attribute.sr.binding.sid.sub.tlvs.Ipv6PrefixSidParser.IPV6_PREFIX_SID;
import static org.opendaylight.protocol.bgp.linkstate.impl.attribute.sr.binding.sid.sub.tlvs.SIDParser.SID_TYPE;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.writeUint16;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.range.sub.tlvs.range.sub.tlv.prefix.sid.tlv._case.PrefixSidTlvBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.range.tlv.SubTlvs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.range.tlv.SubTlvsBuilder;
-import org.opendaylight.yangtools.yang.common.netty.ByteBufUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
range.setInterArea(Boolean.FALSE);
}
buffer.skipBytes(RESERVED);
- range.setRangeSize(ByteBufUtils.readUint16(buffer));
+ range.setRangeSize(readUint16(buffer));
range.setSubTlvs(parseRangeSubTlvs(buffer, protocolId));
return range.build();
}
flags.set(INNER_AREA, srRange.getInterArea());
flags.toByteBuf(aggregator);
aggregator.writeZero(RESERVED);
- aggregator.writeShort(srRange.getRangeSize().toJava());
+ writeUint16(aggregator, srRange.getRangeSize());
serializeSubTlvs(aggregator, srRange.getSubTlvs());
}
package org.opendaylight.protocol.bgp.linkstate.impl.attribute.sr;
import static org.opendaylight.protocol.bgp.linkstate.impl.attribute.LinkAttributesParser.SR_LAN_ADJ_ID;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.writeUint8;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.adj.flags.flags.ospf.adj.flags._case.OspfAdjFlagsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.sid.label.index.SidLabelIndex;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.IsoSystemIdentifier;
-import org.opendaylight.yangtools.yang.common.netty.ByteBufUtils;
public final class SrLinkAttributesParser {
private static final int ISO_SYSTEM_ID_SIZE = 6;
if (buffer.isReadable()) {
final BitArray flags = BitArray.valueOf(buffer, FLAGS_BITS_SIZE);
adjFlags = parseFlags(flags, protocolId);
- weight = new Weight(ByteBufUtils.readUint8(buffer));
+ weight = new Weight(readUint8(buffer));
buffer.skipBytes(RESERVED);
final boolean isValue;
final boolean isLocal;
final SidLabelIndex sidValue;
if (buffer.isReadable()) {
final BitArray flags = BitArray.valueOf(buffer, FLAGS_BITS_SIZE);
- weight = new Weight(ByteBufUtils.readUint8(buffer));
+ weight = new Weight(readUint8(buffer));
buffer.skipBytes(RESERVED);
sidValue = SidLabelIndexParser.parseSidLabelIndexByFlags(Size.forValue(buffer.readableBytes()), buffer,
flags.get(VALUE_EPE), flags.get(LOCAL_EPE));
final SrLanAdjIdsBuilder srLanAdjIdBuilder = new SrLanAdjIdsBuilder();
final BitArray flags = BitArray.valueOf(buffer, FLAGS_BITS_SIZE);
srLanAdjIdBuilder.setFlags(parseFlags(flags, protocolId));
- srLanAdjIdBuilder.setWeight(new Weight(ByteBufUtils.readUint8(buffer)));
+ srLanAdjIdBuilder.setWeight(new Weight(readUint8(buffer)));
buffer.skipBytes(RESERVED);
final boolean isValue;
final boolean isLocal;
} else {
value.writeZero(FLAGS_BYTE_SIZE);
}
- value.writeByte(adjSid.getWeight().getValue().toJava());
+ writeUint8(value, adjSid.getWeight().getValue());
value.writeZero(RESERVED);
value.writeBytes(SidLabelIndexParser.serializeSidValue(adjSid.getSidLabelIndex()));
return value;
final ByteBuf value = Unpooled.buffer();
final BitArray flags = serializeAdjFlags(srLanAdjId.getFlags(), srLanAdjId.getSidLabelIndex());
flags.toByteBuf(value);
- value.writeByte(srLanAdjId.getWeight().getValue().toJava());
+ writeUint8(value, srLanAdjId.getWeight().getValue());
value.writeZero(RESERVED);
if (srLanAdjId.getIsoSystemId() != null) {
value.writeBytes(srLanAdjId.getIsoSystemId().getValue());
package org.opendaylight.protocol.bgp.linkstate.impl.attribute.sr.binding.sid.sub.tlvs;
import static com.google.common.base.Preconditions.checkArgument;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.writeUint32;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.binding.sub.tlvs.binding.sub.tlv.EroMetricCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.binding.sub.tlvs.binding.sub.tlv.EroMetricCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.TeMetric;
-import org.opendaylight.yangtools.yang.common.netty.ByteBufUtils;
public final class EroMetricParser implements BindingSubTlvsParser, BindingSubTlvsSerializer {
private static final int ERO_METRIC = 1162;
@Override
public BindingSubTlv parseSubTlv(final ByteBuf slice, final ProtocolId protocolId) {
- return new EroMetricCaseBuilder().setEroMetric(new TeMetric(ByteBufUtils.readUint32(slice))).build();
+ return new EroMetricCaseBuilder().setEroMetric(new TeMetric(readUint32(slice))).build();
}
@Override
public void serializeSubTlv(final BindingSubTlv bindingSubTlv, final ByteBuf aggregator) {
checkArgument(bindingSubTlv instanceof EroMetricCase, "Wrong BindingSubTlv instance expected",
bindingSubTlv);
- final ByteBuf buffer = Unpooled.buffer();
- buffer.writeInt(((EroMetricCase) bindingSubTlv).getEroMetric().getValue().intValue());
+ final ByteBuf buffer = Unpooled.buffer(4);
+ writeUint32(buffer, ((EroMetricCase) bindingSubTlv).getEroMetric().getValue());
TlvUtil.writeTLV(getType(), buffer, aggregator);
}
}
package org.opendaylight.protocol.bgp.linkstate.impl.attribute.sr.binding.sid.sub.tlvs;
import static com.google.common.base.Preconditions.checkArgument;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
+import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.writeUint32;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.binding.sub.tlvs.binding.sub.tlv.unnumbered._interface.id.ero._case.UnnumberedInterfaceIdEro;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev200120.binding.sub.tlvs.binding.sub.tlv.unnumbered._interface.id.ero._case.UnnumberedInterfaceIdEroBuilder;
import org.opendaylight.yangtools.yang.common.Uint32;
-import org.opendaylight.yangtools.yang.common.netty.ByteBufUtils;
public final class UnnumberedEroParser implements BindingSubTlvsParser, BindingSubTlvsSerializer {
private static final int UNNUMBERED_ERO = 1165;
final BitArray flags = BitArray.valueOf(buffer, Ipv4EroParser.FLAGS_SIZE);
builder.setLoose(flags.get(Ipv4EroParser.LOOSE));
buffer.skipBytes(Ipv4EroParser.RESERVED_ERO);
- builder.setRouterId(ByteBufUtils.readUint32(buffer));
- builder.setInterfaceId(ByteBufUtils.readUint32(buffer));
+ builder.setRouterId(readUint32(buffer));
+ builder.setInterfaceId(readUint32(buffer));
return new UnnumberedInterfaceIdEroCaseBuilder().setUnnumberedInterfaceIdEro(builder.build()).build();
}
final BitArray flags = BitArray.valueOf(buffer, Ipv4EroParser.FLAGS_SIZE);
builder.setLoose(flags.get(Ipv4EroParser.LOOSE));
buffer.skipBytes(Ipv4EroParser.RESERVED_ERO);
- builder.setRouterId(ByteBufUtils.readUint32(buffer));
- builder.setInterfaceId(ByteBufUtils.readUint32(buffer));
+ builder.setRouterId(readUint32(buffer));
+ builder.setInterfaceId(readUint32(buffer));
return new UnnumberedInterfaceIdBackupEroCaseBuilder().setUnnumberedInterfaceIdBackupEro(builder.build())
.build();
}
static ByteBuf serializeUnnumberedIdEro(final Boolean loose, final Uint32 routerId, final Uint32 interfaceId) {
final ByteBuf buffer = Unpooled.buffer();
Ipv4EroParser.serializeEroFlags(buffer, loose);
- buffer.writeInt(routerId.intValue());
- buffer.writeInt(interfaceId.intValue());
+ writeUint32(buffer, routerId);
+ writeUint32(buffer, interfaceId);
return buffer;
}
}