示例#1
0
  /**
   * 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");
    }
  }
示例#2
0
  /** Updates the table. */
  public void update() {

    Vector<RowObjectContainer> conts;
    Iterator iter;
    ReadPoint[] readPoints;
    Source[] sources;
    NotificationChannel[] notifChans;

    ReaderDevice readerDevice = null;
    try {
      readerDevice = ReaderDevice.getInstance();
    } catch (ReaderProtocolException rpe) {
      log.warn("Unable to obtain the ReaderDevice instance");
    }

    switch (type) {
      case EPCG_GLOBAL_COUNTERS_TABLE:
        // do nothing
        break;
      case EPCG_READER_SERVER_TABLE:
        if (readerDevice != null) {
          String dhcp = readerDevice.getDHCPServer();
          String[] ntp = readerDevice.getNTPservers();
          conts = new Vector<RowObjectContainer>((dhcp == null ? 0 : 1) + ntp.length);
          if (dhcp != null) {
            conts.add(
                new RowObjectContainer(
                    TableTypeEnum.EPCG_READER_SERVER_TABLE,
                    new Object[] {ServerTypeEnum.DHCP, dhcp}));
          }
          for (int i = 0; i < ntp.length; i++) {
            conts.add(
                new RowObjectContainer(
                    TableTypeEnum.EPCG_READER_SERVER_TABLE,
                    new Object[] {ServerTypeEnum.TIME, ntp[i]}));
          }
          iter = getModel().iterator();
          while (iter.hasNext()) {
            SnmpTableRow row = (SnmpTableRow) iter.next();
            if (((Integer32) row.getValue(EpcglobalReaderMib.idxEpcgReaderServerRowStatus)).toInt()
                == RowStatus.notInService) {
              conts.add(row.getRowObjectContainer());
            }
          }
          updateStoredRows(conts);
        } else {
          log.error(type + ": Unable to update.");
        }
        break;
      case EPCG_READ_POINT_TABLE:
        if (readerDevice != null) {
          readPoints = readerDevice.getAllReadPoints();
          conts = new Vector<RowObjectContainer>(readPoints.length);
          for (int i = 0; i < readPoints.length; i++) {
            conts.add(
                new RowObjectContainer(
                    TableTypeEnum.EPCG_READ_POINT_TABLE, new Object[] {readPoints[i]}));
          }
          updateStoredRows(conts);
        } else {
          log.error(type + ": Unable to update.");
        }
        break;
      case EPCG_ANT_READ_POINT_TABLE:
        if (readerDevice != null) {
          readPoints = readerDevice.getAllReadPoints();
          conts = new Vector<RowObjectContainer>();
          for (int i = 0; i < readPoints.length; i++) {
            if (readPoints[i] instanceof AntennaReadPoint) {
              conts.add(
                  new RowObjectContainer(
                      TableTypeEnum.EPCG_ANT_READ_POINT_TABLE, new Object[] {readPoints[i]}));
            }
          }
          updateStoredRows(conts);
        } else {
          log.error(type + ": Unable to update.");
        }
        break;
      case EPCG_IO_PORT_TABLE:
        if (readerDevice != null) {
          IOPort[] ioPorts = readerDevice.getAllIOPorts();
          conts = new Vector<RowObjectContainer>(ioPorts.length);
          for (int i = 0; i < ioPorts.length; i++) {
            conts.add(
                new RowObjectContainer(
                    TableTypeEnum.EPCG_IO_PORT_TABLE, new Object[] {ioPorts[i]}));
          }
          updateStoredRows(conts);
        } else {
          log.error(type + ": Unable to update.");
        }
        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;
    }
  }