import org.openflow.protocol.statistics.OFTableStatistics; //导入依赖的package包/类
/**
 * OFTableStatistics builder
 *
 * @return the list
 */
private List<OFTableStatistics> tableStatBuilder() {
    List<OFTableStatistics> tableStats = new ArrayList<>();

    for (int i = 0; i < this.flow_table.size(); i++) {
        OFTableStatistics tableStat = new OFTableStatistics();
        tableStat.setActiveCount(42);
        tableStat.setLookupCount(42);
        tableStat.setMatchedCount(42);
        tableStat.setMaximumEntries(this.flow_table.capacity());
        tableStat.setName("toblerOne");
        tableStat.setTableId((byte) 42);

        tableStats.add(tableStat);
    }

    return tableStats;
}
 

import org.openflow.protocol.statistics.OFTableStatistics; //导入依赖的package包/类
public List<OFStatistics> filterTableListPerContainer(
        String container, long switchId, List<OFStatistics> list) {
    if (list == null) {
        return null;
    }

    // Create new filtered list of node tables
    List<OFStatistics> newList = new ArrayList<OFStatistics>();

    for (OFStatistics stat : list) {
        OFTableStatistics target = (OFTableStatistics) stat;
        NodeTable nt = NodeTableCreator.createOFNodeTable(target.getTableId(), NodeCreator.createOFNode(switchId));
        if (containerOwnsNodeTable(container, nt)) {
            newList.add(target);
        }
    }

    return newList;
}
 

import org.openflow.protocol.statistics.OFTableStatistics; //导入依赖的package包/类
@LogMessageDocs({
    @LogMessageDoc(level="INFO",
        message="Switch {switch} flow table is full",
        explanation="The switch flow table at least 98% full, " +
                "this requires attention if using reactive flow setup"),
    @LogMessageDoc(level="INFO",
        message="Switch {switch} flow table capacity back to normal",
        explanation="The switch flow table is less than 90% full")
})
private void checkForTableStats(OFStatisticsReply statReply) {
    if (statReply.getStatisticType() != OFStatisticsType.TABLE) {
        return;
    }
    List<? extends OFStatistics> stats = statReply.getStatistics();
    // Assume a single table only
    OFStatistics stat = stats.get(0);
    if (stat instanceof OFTableStatistics) {
        OFTableStatistics tableStat = (OFTableStatistics) stat;
        int activeCount = tableStat.getActiveCount();
        int maxEntry = tableStat.getMaximumEntries();
        log.debug("Switch {} active entries {} max entries {}",
                new Object[] { this.stringId, activeCount, maxEntry});
        int percentFull = activeCount * 100 / maxEntry;
        if (flowTableFull && percentFull < 90) {
            log.info("Switch {} flow table capacity is back to normal",
                    toString());
            floodlightProvider.addSwitchEvent(this.datapathId,
                    "SWITCH_FLOW_TABLE_NORMAL < 90% full", false);
        } else if (percentFull >= 98) {
            log.info("Switch {} flow table is almost full", toString());
            floodlightProvider.addSwitchEvent(this.datapathId,
                    "SWITCH_FLOW_TABLE_ALMOST_FULL >= 98% full", false);
        }
    }
}
 

import org.openflow.protocol.statistics.OFTableStatistics; //导入依赖的package包/类
@Override
public List<OFStatistics> getOFTableStatistics(Long switchId, Byte tableId) {
    if (!tableStatistics.containsKey(switchId)) {
        return this.dummyList;
    }

    List<OFStatistics> list = new ArrayList<OFStatistics>(1);
    for (OFStatistics stats : tableStatistics.get(switchId)) {
        if (((OFTableStatistics) stats).getTableId() == tableId) {
            list.add(stats);
            break;
        }
    }
    return list;
}
 

import org.openflow.protocol.statistics.OFTableStatistics; //导入依赖的package包/类
/**
 * Parses message into relevant properties
 * @param statsType the specific Stats Type (0:DESC, 1:FLOW, 2:AGGREGATE, 3:TABLE, 4:PORT, 5:QUEUE, 6:VENDOR)
 * @param rawMessage Assumes the following format and parses into properties:
 * "["flow_stats_reply", 3, [{"packet_count": 0, "hard_timeout": 0, "byte_count": 0, "idle_timeout": 0, "actions": "[{'output': 65533}]", 
 * 							  "duration_nsec": 27000000, "priority": 0, "duration_sec": 0, "table_id": 0, "cookie": 0, "match": "{}"}]]"
 */
public OFStatisticsReply parseStatsReply(OFStatisticsType statsType, String rawMessage) {
	//EXTRACT THE JSON
	String tmp = rawMessage.substring(rawMessage.indexOf(",")+2, rawMessage.length()-2);
	String switchStr = tmp.substring(0, 1);
	this.switchId = Long.parseLong(switchStr);
	String jsonStr = tmp.substring(tmp.indexOf(",")+3);
	JSONObject json = new JSONObject(jsonStr);
	
	//ADD PROPS TO STATS_REPLY OBJECT
	OFStatisticsReply statsReply = new OFStatisticsReply();
	//statsReply.setFlags(Short.parseShort(flagStr));
	statsReply.setStatisticType(statsType);
	statsReply.setStatisticsFactory(new BasicFactory());
	List<OFStatistics> statistics = new ArrayList<OFStatistics>();
	switch (statsType) {
		case DESC:
			OFDescriptionStatistics description = new OFDescriptionStatistics();
			description.setDatapathDescription("A");
			description.setHardwareDescription("B");
			description.setManufacturerDescription("C");
			description.setSerialNumber("D");
			description.setSoftwareDescription("E");
			statistics.add(description);
			break;
		case FLOW:
			OFFlowStatisticsReply flowStats = new OFFlowStatisticsReply();
			flowStats.setByteCount(json.getLong("byte_count"));
			flowStats.setActionFactory(new BasicFactory());
			//FORMATTING SEEMS OFF (why is it in " "), NEED TO CONVERT STRING TO JSON ARRAY
			String tmpArrayStr = json.getString("actions");
			JSONArray jsonArray = new JSONArray(tmpArrayStr);
			flowStats.setActions(parseActionsArray(jsonArray));
			//
			flowStats.setCookie(json.getLong("cookie"));
			flowStats.setDurationNanoseconds(json.getInt("duration_nsec"));
			flowStats.setDurationSeconds(json.getInt("duration_sec"));
			flowStats.setHardTimeout((short)json.getInt("hard_timeout"));
			flowStats.setIdleTimeout((short)json.getInt("idle_timeout"));
			flowStats.setPacketCount(json.getLong("packet_count"));
			flowStats.setPriority((short)json.getInt("priority"));
			flowStats.setTableId((byte)json.getInt("table_id"));
			OFMatch match = new OFMatch();
			flowStats.setMatch(match);
			statistics.add(flowStats);
			break;
		case TABLE:
			OFTableStatistics tables = new OFTableStatistics();
			tables.setTableId(Byte.parseByte(json.getString("table_id")));
			//tables.setActiveCount();
			//tables.setLookupCount(lookupCount);
			//tables.setMatchedCount(matchedCount);
			//tables.setMaximumEntries(maximumEntries);
			//tables.setWildcards(wildcards);
			statistics.add(tables);
			break;
		case PORT:
			OFPortStatisticsReply portStatReply = new OFPortStatisticsReply();
			portStatReply.setreceivePackets(json.getLong("packet_count"));
			portStatReply.setPortNumber(Short.parseShort(json.getString("port")));
			portStatReply.setReceiveBytes(json.getLong("received_bytes"));
			statistics.add(portStatReply);
			break;
		case AGGREGATE:
		case VENDOR:
		case QUEUE:
	}
	statsReply.setStatistics(statistics);
	return statsReply;
}