tableutils.java

snmp4j

        }
      }
      lastSent = new Vector(sz+1);
      for (int i=sent; i<sent+sz; i++) {
        OID col = (OID)lastReceived.get(i);
        VariableBinding vb = new VariableBinding(col);
        pdu.add(vb);
        if (pdu.getBERLength() > target.getMaxSizeRequestPDU()) {
          pdu.trim();
          break;
        }
        else {
          lastSent.add(lastReceived.get(i));
        }
      }
      try {
        Integer startCol = new Integer(sent);
        sent += pdu.size();
        session.send(pdu, target, startCol, this);
      }
      catch (Exception ex) {
        logger.error(ex);
        if (logger.isDebugEnabled()) {
          ex.printStackTrace();
        }
        return false;
      }
      return true;
    }

    public synchronized void onResponse(ResponseEvent event) {
      // Do not forget to cancel the asynchronous request! ;-)
      session.cancel(event.getRequest(), this);
      if (finished) {
        return;
      }
      if (checkResponse(event)) {
        boolean anyMatch = false;
        int startCol = ((Integer)event.getUserObject()).intValue();
        PDU request = event.getRequest();
        PDU response = event.getResponse();
        int cols = request.size();
        int rows = response.size() / cols;
        OID lastMinIndex = null;
        for (int r=0; r<rows; r++) {
          Row row = null;
          for (int c=0; c<request.size(); c++) {
            int pos = startCol + c;
            VariableBinding vb = response.get(r*cols+c);
            if (vb.isException()) {
              continue;
            }
            OID id = vb.getOid();
            OID col = columnOIDs[pos];
            if (id.startsWith(col)) {
              OID index =
                    new OID(id.getValue(), col.size(), id.size() - col.size());
              if ((upperBoundIndex != null) &&
                  (index.compareTo(upperBoundIndex)>0)) {
                continue;
              }
              if ((lastMinIndex == null) ||
                  (index.compareTo(lastMinIndex) < 0)) {
                lastMinIndex = index;
              }
              anyMatch = true;
              if ((row == null) || (!row.getRowIndex().equals(index))) {
                row = null;
                for (ListIterator it = rowCache.listIterator(rowCache.size());
                     it.hasPrevious(); ) {
                  Row lastRow = (Row) it.previous();
                  int compareResult = index.compareTo(lastRow.getRowIndex());
                  if (compareResult == 0) {
                    row = lastRow;
                    break;
                  }
                  else if (compareResult > 0) {
                    break;
                  }
                }
              }
              if (row == null) {
                row = new Row(index);
                if (rowCache.size() == 0) {
                  rowCache.add(row);
                }
                else if (((Row)rowCache.getFirst()).getRowIndex().compareTo(index) >= 0) {
                  rowCache.addFirst(row);
                }
                else {
                  for (ListIterator it = rowCache.listIterator(rowCache.size());
                       it.hasPrevious(); ) {
                    Row lastRow = (Row) it.previous();
                    if (index.compareTo(lastRow.index) >= 0) {
                      it.set(row);
                      it.add(lastRow);
                     break;
                   }
                 }
               }
             }
             if (((!row.setNumComplete(pos)) ||
                  (row.size() > pos)) && (row.get(pos) != null)) {
                listener.finished(new TableEvent(this, userObject,
                                                 TableEvent.STATUS_WRONG_ORDER));
                return;
              }
              row.setNumComplete(pos);
              if (pos < row.getNumComplete()) {
                row.set(pos, vb);
              }
              else {
                row.add(vb);
              }
              lastReceived.set(pos, vb.getOid());
            }
          }
        }
        while ((rowCache.size() > 0) &&
               (((Row)rowCache.getFirst()).getNumComplete() == columnOIDs.length) &&
               ((lastMinIndex == null) ||
                (((Row)rowCache.getFirst()).getRowIndex().compareTo(lastMinIndex) < 0))){
          if (!listener.next(getTableEvent())) {
            listener.finished(new TableEvent(this, userObject));
            return;
          }
        }
        if (!sendNextChunk()) {
          if (anyMatch) {
            sent = 0;
            sendNextChunk();
          }
          else {
            emptyCache();
            listener.finished(new TableEvent(this, userObject));
          }
        }
      }
    }

    protected boolean checkResponse(ResponseEvent event) {
      if (event.getError() != null) {
        finished = true;
        emptyCache();
        listener.finished(new TableEvent(this, userObject, event.getError()));
      }
      else if (event.getResponse() == null) {
        finished = true;
        // timeout
        emptyCache();
        listener.finished(new TableEvent(this, userObject,
                                         TableEvent.STATUS_TIMEOUT));
      }
      else if (event.getResponse().getType() == PDU.REPORT) {
        finished = true;
        emptyCache();
        listener.finished(new TableEvent(this, userObject,
                                         event.getResponse()));
      }
      else if (event.getResponse().getErrorStatus() != PDU.noError) {
        finished = true;
        emptyCache();
        listener.finished(new TableEvent(this, userObject,
                                         event.getResponse().getErrorStatus()));
      }
      else {
        return true;
      }
      return false;
    }

    private void emptyCache() {
      while (rowCache.size() > 0) {
        if (!listener.next(getTableEvent())) {
          break;
        }
      }
    }

    private TableEvent getTableEvent() {
      Row r = (Row) rowCache.removeFirst();
      r.setNumComplete(columnOIDs.length);
      VariableBinding[] vbs = new VariableBinding[r.size()];
      r.copyInto(vbs);
      return new TableEvent(this, userObject, r.getRowIndex(), vbs);
    }

    public Row getRow(OID index) {
      for (ListIterator it = rowCache.listIterator(rowCache.size()+1);
           it.hasPrevious(); ) {
        Row r = (Row) it.previous();
        if (index.equals(r.getRowIndex())) {
          return r;
        }
      }
      return null;
    }

  }

  /**
   * The <code>DenseTableRequest</code> extends TableRequest to implement a
   * faster table retrieval than the original. Caution:
   * This version does not correctly retrieve sparse tables!
   *
   * @author Frank Fock
   * @since 1.5
   */
  class DenseTableRequest extends TableRequest {
    protected DenseTableRequest(Target target,
                                OID[] columnOIDs,
                                TableListener listener,
                                Object userObject,
                                OID lowerBoundIndex,
                                OID upperBoundIndex) {
      super(target, columnOIDs, listener, userObject, lowerBoundIndex,
            upperBoundIndex);
    }

    public synchronized void onResponse(ResponseEvent event) {
      // Do not forget to cancel the asynchronous request! ;-)
      session.cancel(event.getRequest(), this);
      if (finished) {
        return;
      }
      if (checkResponse(event)) {
        boolean anyMatch = false;
        int startCol = ((Integer)event.getUserObject()).intValue();
        PDU request = event.getRequest();
        PDU response = event.getResponse();
        int cols = request.size();
        int rows = response.size() / cols;
        OID lastMinIndex = null;
        for (int r=0; r<rows; r++) {
          Row row = null;
          for (int c=0; c<request.size(); c++) {
            int pos = startCol + c;
            VariableBinding vb = response.get(r*cols+c);
            if (vb.isException()) {
              continue;
            }
            OID id = vb.getOid();
            OID col = columnOIDs[pos];
            if (id.startsWith(col)) {
              OID index =
                    new OID(id.getValue(), col.size(), id.size() - col.size());
              if ((upperBoundIndex != null) &&
                  (index.compareTo(upperBoundIndex)>0)) {
                continue;
              }
              if ((lastMinIndex == null) ||
                  (index.compareTo(lastMinIndex) < 0)) {
                lastMinIndex = index;
              }
              anyMatch = true;
              if (row == null) {
                row = new Row(index);
              }
              row.setNumComplete(pos);
              if (pos < row.getNumComplete()) {
                row.set(pos, vb);
              }
              else {
                row.add(vb);
              }
              lastReceived.set(pos, vb.getOid());
            }
          }
          if (row != null) {
            if (!listener.next(new TableEvent(this, userObject, row.getRowIndex(),
                                              (VariableBinding[])
                                              row.toArray(new VariableBinding[0])))) {
              listener.finished(new TableEvent(this, userObject));
              return;
            }
          }
        }
        if (!sendNextChunk()) {
          listener.finished(new TableEvent(this, userObject));
        }
      }
    }
  }

  class Row extends Vector {

    private OID index;

    public Row(OID index) {
      super();
      this.index = index;
    }

    public OID getRowIndex() {
      return index;
    }

    public int getNumComplete() {
      return super.size();
    }

    public boolean setNumComplete(int numberOfColumnsComplete) {
      int sz = numberOfColumnsComplete - getNumComplete();
      for (int i=0; i<sz; i++) {
        super.add(null);
      }
      return (sz >= 0);
    }

  }


  class InternalTableListener implements TableListener {

    private LinkedList rows = new LinkedList();

    public boolean next(TableEvent event) {
      rows.add(event);
      return true;
    }

    public synchronized void finished(TableEvent event) {
      if ((event.getStatus() != TableEvent.STATUS_OK) ||
          (event.getIndex() != null)) {
        rows.add(event);
      }
      notify();
    }

    public List getRows() {
      return rows;
    }
  }
}