snmptable.java

关于 RFID 读写器的相关内容

				break;
			case EPCG_SOURCE_TABLE:
				if (readerDevice != null) {
					sources = readerDevice.getAllSources();
					conts = new Vector<RowObjectContainer>(sources.length);
					for (int i = 0; i < sources.length; i++) {
						conts.add(new RowObjectContainer(TableTypeEnum.EPCG_SOURCE_TABLE, new Object[] {sources[i]}));
					}
				updateStoredRows(conts);
				} else {
					log.error(type + ": Unable to update.");
				}
				break;
			case EPCG_NOTIFICATION_CHANNEL_TABLE:
				if (readerDevice != null) {
					notifChans = readerDevice.getAllNotificationChannels();
					conts = new Vector<RowObjectContainer>(notifChans.length);
					for (int i = 0; i < notifChans.length; i++) {
						conts.add(new RowObjectContainer(TableTypeEnum.EPCG_NOTIFICATION_CHANNEL_TABLE, new Object[] {notifChans[i]}));
					}
					updateStoredRows(conts);
				} else {
					log.error(type + ": Unable to update.");
				}
				break;
			case EPCG_TRIGGER_TABLE:
				if (readerDevice != null) {
					Trigger[] triggers = readerDevice.getAllTriggers();
					conts = new Vector<RowObjectContainer>(triggers.length);
					for (int i = 0; i < triggers.length; i++) {
						conts.add(new RowObjectContainer(TableTypeEnum.EPCG_TRIGGER_TABLE, new Object[] {triggers[i]}));
					}
					updateStoredRows(conts);
				} else {
					log.error(type + ": Unable to update.");
				}
				break;
			case EPCG_NOTIF_TRIG_TABLE:
				if (readerDevice != null) {
					notifChans = readerDevice.getAllNotificationChannels();
					conts = new Vector<RowObjectContainer>();
					for (int i = 0; i < notifChans.length; i++) {
						Trigger[] triggers = notifChans[i].getAllNotificationTriggers();
						for (int j = 0; j < triggers.length; j++) {
							conts.add(new RowObjectContainer(TableTypeEnum.EPCG_NOTIF_TRIG_TABLE, new Object[] { notifChans[i], triggers[j] }));
						}
					}
					iter = getModel().iterator();
					while (iter.hasNext()) {
						SnmpTableRow row = (SnmpTableRow) iter.next();
						if (((Integer32) row.getValue(EpcglobalReaderMib.idxEpcgNotifTrigRowStatus)).toInt() == RowStatus.notInService) {
							conts.add(row.getRowObjectContainer());
						}
					}
					updateStoredRows(conts);
				} else {
					log.error(type + ": Unable to update.");
				}
				break;
			case EPCG_READ_TRIG_TABLE:
				if (readerDevice != null) {
					sources = readerDevice.getAllSources();
					conts = new Vector<RowObjectContainer>();
					for (int i = 0; i < sources.length; i++) {
						Trigger[] triggers = sources[i].getAllReadTriggers();
						for (int j = 0; j < triggers.length; j++) {
							conts.add(new RowObjectContainer(TableTypeEnum.EPCG_READ_TRIG_TABLE, new Object[] { sources[i], triggers[j] }));
						}
					}
					iter = getModel().iterator();
					while (iter.hasNext()) {
						SnmpTableRow row = (SnmpTableRow) iter.next();
						if (((Integer32) row.getValue(EpcglobalReaderMib.idxEpcgReadTrigRowStatus)).toInt() == RowStatus.notInService) {
							conts.add(row.getRowObjectContainer());
						}
					}
					updateStoredRows(conts);
				} else {
					log.error(type + ": Unable to update.");
				}
				break;
			case EPCG_RD_PNT_SRC_TABLE:
				if (readerDevice != null) {
					sources = readerDevice.getAllSources();
					conts = new Vector<RowObjectContainer>();
					for (int i = 0; i < sources.length; i++) {
						readPoints = sources[i].getAllReadPoints();
						for (int j = 0; j < readPoints.length; j++) {
							conts.add(new RowObjectContainer(TableTypeEnum.EPCG_RD_PNT_SRC_TABLE, new Object[] { sources[i], readPoints[j] }));
						}
					}
					iter = getModel().iterator();
					while (iter.hasNext()) {
						SnmpTableRow row = (SnmpTableRow) iter.next();
						if (((Integer32) row.getValue(EpcglobalReaderMib.idxEpcgRdPntSrcRowStatus)).toInt() == RowStatus.notInService) {
							conts.add(row.getRowObjectContainer());
						}
					}
					updateStoredRows(conts);
				} else {
					log.error(type + ": Unable to update.");
				}
				break;
			case EPCG_NOTIF_CHAN_SRC_TABLE:
				if (readerDevice != null) {
					sources = readerDevice.getAllSources();
					conts = new Vector<RowObjectContainer>();
					for (int i = 0; i < sources.length; i++) {
						Enumeration notifChansIter = sources[i].getAllNotificationChannels().elements();
						while (notifChansIter.hasMoreElements()) {
							NotificationChannel curNotifChan = (NotificationChannel)notifChansIter.nextElement();
							conts.add(new RowObjectContainer(TableTypeEnum.EPCG_NOTIF_CHAN_SRC_TABLE, new Object[] { curNotifChan, sources[i] }));
						}
					}
					iter = getModel().iterator();
					while (iter.hasNext()) {
						SnmpTableRow row = (SnmpTableRow) iter.next();
						if (((Integer32) row.getValue(EpcglobalReaderMib.idxEpcgNotifChanSrcRowStatus)).toInt() == RowStatus.notInService) {
							conts.add(row.getRowObjectContainer());
						}
					}
					updateStoredRows(conts);
				} else {
					log.error(type + ": Unable to update.");
				}
				break;
			case IF_TABLE:
				// TODO: implement this
				break;
			case IP_ADDR_TABLE:
				// TODO: implement this
				break;
			case IP_NET_TO_MEDIA_TABLE:
				// TODO: implement this
				break;
			case SNMP_TARGET_ADDR_TABLE:
				// TODO: implement this
				break;
			case SNMP_TARGET_PARAMS_TABLE:
				// TODO: implement this
				break;
			case SYS_OR_TABLE:
				// TODO: implement this
				break;
		}
	}
	
	/**
	 * Updates the table in a way that there exists for every given
	 * <code>RowObjectContainer</code> object one table row.
	 * 
	 * @param conts
	 *            <code>RowObjectContainer</code> objects
	 */
	public void updateStoredRows(Vector<RowObjectContainer> conts) {
		Vector<RowObjectContainer> oldConts = new Vector<RowObjectContainer>(); // row object containers that are already listet in the table
		Vector<RowObjectContainer> newConts = new Vector<RowObjectContainer>(); // new row object containers that should be added to the table
		Vector<RowObjectContainer> delConts = new Vector<RowObjectContainer>(); // row object containers that should be remove from the table
		
		Vector<RowObjectContainer> storedConts = new Vector<RowObjectContainer>();
		Iterator iter = getModel().iterator();
		while (iter.hasNext()) {
			storedConts.add(((SnmpTableRow)iter.next()).getRowObjectContainer());
		}
		
		Enumeration<RowObjectContainer> elements;
		
		// find already existing and new row object containers in the table
		elements = conts.elements();
		while (elements.hasMoreElements()) {
			RowObjectContainer curCont = elements.nextElement();
			if (storedConts.contains(curCont)) {
				oldConts.add(curCont);
			} else {
				newConts.add(curCont);
			}
		}
		
		// find row object containers that should be deleted from the table
		elements = storedConts.elements();
		while (elements.hasMoreElements()) {
			RowObjectContainer curCont = elements.nextElement();
			if (!conts.contains(curCont)) {
				delConts.add(curCont);
			}
		}
		
		// find rows that should be deleted
		Vector<SnmpTableRow> delRows = new Vector<SnmpTableRow>(); // the rows that should be deleted will be stored here
		Iterator rowIterator = getModel().iterator();
		while (rowIterator.hasNext()) {
			SnmpTableRow row = (SnmpTableRow)(rowIterator.next());
			if ((row.getRowObjectContainer().getRowObjects() == null) || (delConts.contains(row.getRowObjectContainer()))) {
				delRows.add(row);
			}
		}
		
		// delete rows
		Enumeration<SnmpTableRow> delElements = delRows.elements();
		while (delElements.hasMoreElements()) {
			SnmpTableRow row = delElements.nextElement();
			removeRow(row.getIndex());
			log.debug("Row with index " + row.getIndex() + " removed");
		}
		
		// add new rows
		elements = newConts.elements();
		while (elements.hasMoreElements()) {
			RowObjectContainer curCont = elements.nextElement();
			SnmpTableRow row = SnmpTableRow.getSnmpTableRow(curCont);
			addRow(row);
			log.debug("Row with index " + row.getIndex() + " added");
		}
	}
	
	/**
	 * Gets the index of the first row whose value at the specified column
	 * matches a given value.
	 * 
	 * @param value
	 *            The value that has to match
	 * @param column
	 *            The column
	 * @return The index of the first row whose value at the specified column
	 *         matches the given value
	 */
	public OID getTableRowIndexByValue(Variable value, int column) {
		update();
		Vector<OID> indices = getSortedIndices();
		Enumeration<OID> iter = indices.elements();
		while (iter.hasMoreElements()) {
			OID curIndex = iter.nextElement();
			if (getValue(curIndex, column).equals(value))
				return curIndex;
		}
		return null;
	}
	
	/**
	 * Gets the <code>RowObjectContainer</code> of the specified row.
	 * 
	 * @param index
	 *            The row index
	 * @return The <code>RowObjectContainer</code> of the specified row
	 */
	public RowObjectContainer getRowObjContOfRow(OID index) {
		update();
		MOTableRow row = getModel().getRow(index);
		if (row != null) {
			return ((SnmpTableRow)row).getRowObjectContainer();
		}
		return null;
	}
	
//	/**
//	 * Fires a lookup event in order to update this table.
//	 */
//	private void fireLookupEvent() {
//		SnmpAgent snmpAgent = SnmpAgent.getInstance();
//		if (snmpAgent != null) {
//			DefaultMOServer server = snmpAgent.getServer();
//			OctetString[] contexts = server.getContexts();
//			for (int i = 0; i < contexts.length; i++) {
//				server.lookup(new DefaultMOQuery(
//						new DefaultMOContextScope(contexts[i], getOID(), true,
//								getOID().nextPeer(), false)));
//			}
//		}
//	}
}