Java Instructions.TableTypeTransition方法代码示例

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
/**
 * Creates a new traffic treatment from the specified list of instructions.
 *
 * @param deferred deferred instructions
 * @param immediate immediate instructions
 * @param table table transition instruction
 * @param clear instruction to clear the deferred actions list
 */
private DefaultTrafficTreatment(List<Instruction> deferred,
                               List<Instruction> immediate,
                               Instructions.TableTypeTransition table,
                               boolean clear,
                               Instructions.MetadataInstruction meta,
                               Instructions.MeterInstruction meter) {
    this.immediate = ImmutableList.copyOf(checkNotNull(immediate));
    this.deferred = ImmutableList.copyOf(checkNotNull(deferred));
    this.all = new ImmutableList.Builder<Instruction>()
            .addAll(immediate)
            .addAll(deferred)
            .build();
    this.table = table;
    this.meta = meta;
    this.hasClear = clear;
    this.meter = meter;
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
@Override
public Builder add(Instruction instruction) {

    switch (instruction.type()) {
        case NOACTION:
        case OUTPUT:
        case GROUP:
        case QUEUE:
        case L0MODIFICATION:
        case L1MODIFICATION:
        case L2MODIFICATION:
        case L3MODIFICATION:
        case L4MODIFICATION:
        case EXTENSION:
            current.add(instruction);
            break;
        case TABLE:
            table = (Instructions.TableTypeTransition) instruction;
            break;
        case METADATA:
            meta = (Instructions.MetadataInstruction) instruction;
            break;
        case METER:
            meter = (Instructions.MeterInstruction) instruction;
            break;
        default:
            throw new IllegalArgumentException("Unknown instruction type: " +
                                                       instruction.type());
    }

    return this;
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
private OFInstruction buildTableGoto(Instructions.TableTypeTransition i) {
    OFInstruction instruction = factory().instructions().gotoTable(
            TableId.of(i.tableId()));
    return instruction;
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
@Override
public Instructions.TableTypeTransition tableTransition() {
    return table;
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
@Override
public Instructions.TableTypeTransition tableTransition() {
    return null;
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
/**
 * Encodes the given instruction into JSON.
 *
 * @return JSON object node representing the instruction
 */
public ObjectNode encode() {
    final ObjectNode result = context.mapper().createObjectNode()
            .put(InstructionCodec.TYPE, instruction.type().toString());

    switch (instruction.type()) {
        case OUTPUT:
            final Instructions.OutputInstruction outputInstruction =
                    (Instructions.OutputInstruction) instruction;
            result.put(InstructionCodec.PORT, outputInstruction.port().toString());
            break;

        case NOACTION:
            break;

        case GROUP:
            final Instructions.GroupInstruction groupInstruction =
                    (Instructions.GroupInstruction) instruction;
            result.put(InstructionCodec.GROUP_ID, groupInstruction.groupId().toString());
            break;

        case METER:
            final Instructions.MeterInstruction meterInstruction =
                    (Instructions.MeterInstruction) instruction;
            result.put(InstructionCodec.METER_ID, meterInstruction.meterId().toString());
            break;

        case TABLE:
            final Instructions.TableTypeTransition tableTransitionInstruction =
                    (Instructions.TableTypeTransition) instruction;
            result.put(InstructionCodec.TABLE_ID, tableTransitionInstruction.tableId().toString());
            break;

        case QUEUE:
            final Instructions.SetQueueInstruction setQueueInstruction =
                    (Instructions.SetQueueInstruction) instruction;
            result.put(InstructionCodec.QUEUE_ID, setQueueInstruction.queueId());
            result.put(InstructionCodec.PORT, setQueueInstruction.port().toString());
            break;

        case L0MODIFICATION:
            encodeL0(result);
            break;

        case L1MODIFICATION:
            encodeL1(result);
            break;

        case L2MODIFICATION:
            encodeL2(result);
            break;

        case L3MODIFICATION:
            encodeL3(result);
            break;

        case L4MODIFICATION:
            encodeL4(result);
            break;

        case EXTENSION:
            encodeExtension(result);
            break;

        default:
            log.info("Cannot convert instruction type of {}", instruction.type());
            break;
    }
    return result;
}
 

import org.onosproject.net.flow.instructions.Instructions; //导入方法依赖的package包/类
/**
 * Returns the next table in the pipeline.
 * @return a table transition; may be null.
 */
Instructions.TableTypeTransition tableTransition();