import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public ImmutablePair<Long, Boolean> deleteMeter(IOFSwitch sw, final DatapathId dpid, final long meterId) {
    logger.debug("deleting meter {} from switch {}", meterId, dpid);

    OFFactory ofFactory = sw.getOFFactory();

    OFMeterMod.Builder meterDeleteBuilder = ofFactory.buildMeterMod()
            .setMeterId(meterId)
            .setCommand(OFMeterModCommand.DELETE);

    if (sw.getOFFactory().getVersion().compareTo(OF_13) > 0) {
        meterDeleteBuilder.setBands(emptyList());
    } else {
        meterDeleteBuilder.setMeters(emptyList());
    }

    OFMeterMod meterDelete = meterDeleteBuilder.build();

    boolean response = sw.write(meterDelete);
    return new ImmutablePair<>(meterDelete.getXid(), response);
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
private ImmutablePair<Long, Boolean> installMeter(final IOFSwitch sw, final DatapathId dpid, final long bandwidth,
                                                 final long burstSize, final long meterId) {
    logger.debug("installing meter {} on switch {} width bandwidth {}", meterId, dpid, bandwidth);

    Set<OFMeterFlags> flags = new HashSet<>(Arrays.asList(OFMeterFlags.KBPS, OFMeterFlags.BURST));
    OFFactory ofFactory = sw.getOFFactory();

    OFMeterBandDrop.Builder bandBuilder = ofFactory.meterBands()
            .buildDrop()
            .setRate(bandwidth)
            .setBurstSize(burstSize);

    OFMeterMod.Builder meterModBuilder = ofFactory.buildMeterMod()
            .setMeterId(meterId)
            .setCommand(OFMeterModCommand.ADD)
            .setFlags(flags);

    if (sw.getOFFactory().getVersion().compareTo(OF_13) > 0) {
        meterModBuilder.setBands(singletonList(bandBuilder.build()));
    } else {
        meterModBuilder.setMeters(singletonList(bandBuilder.build()));
    }

    OFMeterMod meterMod = meterModBuilder.build();

    boolean response = sw.write(meterMod);
    return new ImmutablePair<>(meterMod.getXid(), response);
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
@Test
public void deleteMeter() {
    final Capture<OFMeterMod> capture = prepareForMeterTest();
    switchManager.deleteMeter(dpid, meterId);
    final OFMeterMod meterMod = capture.getValue();
    assertEquals(meterMod.getCommand(), OFMeterModCommand.DELETE);
    assertEquals(meterMod.getMeterId(), meterId);
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static OFMeterModCommand readFrom(ChannelBuffer bb) throws OFParseError {
    try {
        return ofWireValue(bb.readShort());
    } catch (IllegalArgumentException e) {
        throw new OFParseError(e);
    }
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static OFMeterModCommand ofWireValue(short val) {
    switch(val) {
        case ADD_VAL:
            return OFMeterModCommand.ADD;
        case MODIFY_VAL:
            return OFMeterModCommand.MODIFY;
        case DELETE_VAL:
            return OFMeterModCommand.DELETE;
        default:
            throw new IllegalArgumentException("Illegal wire value for type OFMeterModCommand in version 1.3: " + val);
    }
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static short toWireValue(OFMeterModCommand e) {
    switch(e) {
        case ADD:
            return ADD_VAL;
        case MODIFY:
            return MODIFY_VAL;
        case DELETE:
            return DELETE_VAL;
        default:
            throw new IllegalArgumentException("Illegal enum value for type OFMeterModCommand in version 1.3: " + e);
    }
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static OFMeterModCommand ofWireValue(short val) {
    switch(val) {
        case ADD_VAL:
            return OFMeterModCommand.ADD;
        case MODIFY_VAL:
            return OFMeterModCommand.MODIFY;
        case DELETE_VAL:
            return OFMeterModCommand.DELETE;
        default:
            throw new IllegalArgumentException("Illegal wire value for type OFMeterModCommand in version 1.4: " + val);
    }
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static short toWireValue(OFMeterModCommand e) {
    switch(e) {
        case ADD:
            return ADD_VAL;
        case MODIFY:
            return MODIFY_VAL;
        case DELETE:
            return DELETE_VAL;
        default:
            throw new IllegalArgumentException("Illegal enum value for type OFMeterModCommand in version 1.4: " + e);
    }
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static OFMeterModCommand readFrom(ByteBuf bb) throws OFParseError {
    try {
        return ofWireValue(bb.readShort());
    } catch (IllegalArgumentException e) {
        throw new OFParseError(e);
    }
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static OFMeterModCommand ofWireValue(short val) {
    switch(val) {
        case ADD_VAL:
            return OFMeterModCommand.ADD;
        case MODIFY_VAL:
            return OFMeterModCommand.MODIFY;
        case DELETE_VAL:
            return OFMeterModCommand.DELETE;
        default:
            throw new IllegalArgumentException("Illegal wire value for type OFMeterModCommand in version 1.5: " + val);
    }
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static short toWireValue(OFMeterModCommand e) {
    switch(e) {
        case ADD:
            return ADD_VAL;
        case MODIFY:
            return MODIFY_VAL;
        case DELETE:
            return DELETE_VAL;
        default:
            throw new IllegalArgumentException("Illegal enum value for type OFMeterModCommand in version 1.5: " + e);
    }
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public OFMeterMod add() {
    validate();
    OFMeterMod.Builder builder = builderMeterMod();
    builder.setCommand(OFMeterModCommand.ADD.ordinal());
    return builder.build();
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public OFMeterMod remove() {
    validate();
    OFMeterMod.Builder builder = builderMeterMod();
    builder.setCommand(OFMeterModCommand.DELETE.ordinal());
    return builder.build();
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public OFMeterMod modify() {
    validate();
    OFMeterMod.Builder builder = builderMeterMod();
    builder.setCommand(OFMeterModCommand.MODIFY.ordinal());
    return builder.build();
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static void writeTo(ChannelBuffer bb, OFMeterModCommand e) {
    bb.writeShort(toWireValue(e));
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static void putTo(OFMeterModCommand e, PrimitiveSink sink) {
    sink.putShort(toWireValue(e));
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public OFMeterMod add() {
    validate();
    OFMeterMod.Builder builder = builderMeterMod();
    builder.setCommand(OFMeterModCommand.ADD);
    return builder.build();
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public OFMeterMod remove() {
    validate();
    OFMeterMod.Builder builder = builderMeterMod();
    builder.setCommand(OFMeterModCommand.DELETE);
    return builder.build();
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public OFMeterMod modify() {
    validate();
    OFMeterMod.Builder builder = builderMeterMod();
    builder.setCommand(OFMeterModCommand.MODIFY);
    return builder.build();
}
 

import org.projectfloodlight.openflow.protocol.OFMeterModCommand; //导入依赖的package包/类
public static void writeTo(ByteBuf bb, OFMeterModCommand e) {
    bb.writeShort(toWireValue(e));
}