public void setTimeoutModel(TimeoutModel timeoutModel) {
    if (timeoutModel == null) {
      throw new NullPointerException("Timeout model cannot be null");
    }
    this.timeoutModel = timeoutModel;
  }

  /**
   * Sets the report handler and overrides the default report handler.
   * @param reportHandler
   *    a <code>ReportHandler</code> instance which must not be
   *    <code>null</code>.
   * @since 1.6
   */
  public void setReportHandler(ReportHandler reportHandler) {
    if (reportHandler == null) {
      throw new IllegalArgumentException("ReportHandler must not be null");
    }
    this.reportHandler = reportHandler;
  }

  class PendingRequest extends TimerTask implements PduHandleCallback {

    private PduHandle key;
    protected int retryCount;
    protected ResponseListener listener;
    protected Object userObject;

    protected PDU pdu;
    protected Target target;
    protected TransportMapping transport;

    private int requestStatus = 0;
    // Maximum request status - allows to receive up to two reports and then
    // send the original request again. A value of 0 is used for discovery.
    private int maxRequestStatus = 2;

    private volatile boolean finished = false;


    public PendingRequest(ResponseListener listener,
                          Object userObject,
                          PDU pdu,
                          Target target,
                          TransportMapping transport) {
      this.userObject = userObject;
      this.listener = listener;
      this.retryCount = target.getRetries();
      this.pdu = pdu;
      this.target = target;
      this.transport = transport;
    }

    private PendingRequest(PendingRequest other) {
      this.userObject = other.userObject;
      this.listener = other.listener;
      this.retryCount = other.retryCount - 1;
      this.pdu = other.pdu;
      this.target = other.target;
      this.requestStatus = other.requestStatus;
    }

    protected void registerRequest(PduHandle handle) {

    }

    public synchronized void pduHandleAssigned(PduHandle handle, Object pdu) {
      if (key == null) {
        key = handle;
        pendingRequests.put(handle, this);
        registerRequest(handle);
        if (logger.isDebugEnabled()) {
          logger.debug("Running pending "+
                       ((listener instanceof SyncResponseListener) ?
                        "sync" : "async")+
                       " request with handle " + handle+
                       " and retry count left "+retryCount);
        }
        long delay = timeoutModel.getRetryTimeout(target.getRetries() -
                                                  retryCount,
                                                  target.getRetries(),
                                                  target.getTimeout());
        if (!finished) {
          timer.schedule(this, delay);
        }
      }
    }

    /**
     * Process retries of a pending request.
     */
    public synchronized void run() {
      try {
        if ((!finished) && (retryCount > 0)) {
          try {
            PendingRequest nextRetry = new PendingRequest(this);
            sendMessage(pdu, target, transport, nextRetry);
          }
          catch (IOException ex) {
            finished = true;
            logger.error("Failed to send SNMP message to " + target.toString() +
                         ": " +
                         ex.getMessage());
            messageDispatcher.releaseStateReference(target.getVersion(), key);
            listener.onResponse(new ResponseEvent(Snmp.this, null,
                                                  pdu, null, userObject,
                                                  ex));
          }
        }
        else if (!finished) {
          finished = true;
          pendingRequests.remove(key);

          // request timed out
          if (logger.isDebugEnabled()) {
            logger.debug("Request timed out: " + key.getTransactionID());
          }
          messageDispatcher.releaseStateReference(target.getVersion(), key);
          listener.onResponse(new ResponseEvent(Snmp.this, null,
                                                pdu, null, userObject));
        }
      }
      catch (RuntimeException ex) {
        if (logger.isDebugEnabled()) {
          ex.printStackTrace();
        }
        logger.error("Failed to process pending request " + key +
                     " because " + ex.getMessage(), ex);
        throw ex;
      }
      catch (Error er) {
        if (logger.isDebugEnabled()) {
          er.printStackTrace();
        }
        logger.fatal("Failed to process pending request " + key +
                     " because " + er.getMessage(), er);
        throw er;
      }
    }

    public synchronized boolean setFinished() {
      boolean currentState = finished;
      this.finished = true;
      return currentState;
    }

    public void setMaxRepuestStatus(int maxRepuestStatus) {
      this.maxRequestStatus = maxRepuestStatus;
    }

    public int getMaxRepuestStatus() {
      return maxRequestStatus;
    }

  }

  class AsyncPendingRequest extends PendingRequest {
    public AsyncPendingRequest(ResponseListener listener,
                               Object userObject,
                               PDU pdu,
                               Target target,
                               TransportMapping transport) {
      super(listener, userObject, pdu, target, transport);
    }

    protected void registerRequest(PduHandle handle) {
      AsyncRequestKey key = new AsyncRequestKey(super.pdu, super.listener);
      asyncRequests.put(key, handle);
    }
  }

  static class AsyncRequestKey {
    private PDU request;
    private ResponseListener listener;

    public AsyncRequestKey(PDU request, ResponseListener listener) {
      this.request = request;
      this.listener = listener;
    }

    /**
     * Indicates whether some other object is "equal to" this one.
     *
     * @param obj the reference object with which to compare.
     * @return <code>true</code> if this object is the same as the obj argument;
     *   <code>false</code> otherwise.
     */
    public boolean equals(Object obj) {
      if (obj instanceof AsyncRequestKey) {
        AsyncRequestKey other = (AsyncRequestKey) obj;
        return (request.equals(other.request) && listener.equals(other.listener));
      }
      return false;
    }

    public int hashCode() {
      return request.hashCode();
    }
  }

  static class SyncResponseListener implements ResponseListener {

    private ResponseEvent response = null;

    public synchronized void onResponse(ResponseEvent event) {
      this.response = event;
      this.notify();
    }

    public ResponseEvent getResponse() {
      return response;
    }

  }

  /**
   * The <code>NotificationDispatcher</code> dispatches traps, notifications,
   * and to registered listeners.
   *
   * @author Frank Fock
   * @version 1.6
   * @since 1.6
   */
  class NotificationDispatcher implements CommandResponder {
    // A mapping of transport addresses to transport mappings of notification
    // listeners
    private Hashtable notificationListeners = new Hashtable(10);
    private Hashtable notificationTransports = new Hashtable(10);

    protected NotificationDispatcher() {
    }

    public synchronized void addNotificationListener(Address listenAddress,
                                                     TransportMapping transport,
                                                     CommandResponder listener){
      notificationListeners.put(listenAddress, transport);
      notificationTransports.put(transport, listener);
    }

    public synchronized boolean
        removeNotificationListener(Address listenAddress)
    {
      TransportMapping tm =
          (TransportMapping)notificationListeners.remove(listenAddress);
      if (tm == null) {
        return false;
      }
      tm.removeTransportListener(messageDispatcher);
      notificationTransports.remove(tm);

      try {
        tm.close();
      }
      catch (IOException ex) {
        logger.error(ex);
        if (logger.isDebugEnabled()) {
          ex.printStackTrace();
        }
      }
      return true;
    }

    public synchronized void closeAll() {
      notificationTransports.clear();
      for (Iterator it = notificationListeners.values().iterator();
           it.hasNext();) {
        TransportMapping tm = (TransportMapping) it.next();
        try {
          tm.close();
        }
        catch (IOException ex) {
          logger.error(ex);
          if (logger.isDebugEnabled()) {
            ex.printStackTrace();
          }
        }
      }
      notificationListeners.clear();
    }

    public synchronized void processPdu(CommandResponderEvent event) {
      CommandResponder listener = (CommandResponder)
          notificationTransports.get(event.getTransportMapping());
      if ((event.getPDU() != null) &&
          (event.getPDU().getType() == PDU.INFORM)) {
        // try to send INFORM response
        try {
          sendInformResponse(event);
        }
        catch (MessageException mex) {
          if (logger.isWarnEnabled()) {
            logger.warn("Failed to send response on INFORM PDU event (" +
                        event + "): " + mex.getMessage());
          }
        }
      }
      if (listener != null) {
        listener.processPdu(event);
      }
    }

    /**
     * Sends a RESPONSE PDU to the source address of a INFORM request.
     * @param event
     *    the <code>CommandResponderEvent</code> with the INFORM request.
     * @throws
     *    MessageException if the response could not be created and sent.
     */
    protected void sendInformResponse(CommandResponderEvent event) throws
        MessageException {
      PDU responsePDU = (PDU) event.getPDU().clone();
      responsePDU.setType(PDU.RESPONSE);
      responsePDU.setErrorStatus(PDU.noError);
      responsePDU.setErrorIndex(0);
      messageDispatcher.returnResponsePdu(event.getMessageProcessingModel(),
                                          event.getSecurityModel(),
                                          event.getSecurityName(),
                                          event.getSecurityLevel(),
                                          responsePDU,
                                          event.getMaxSizeResponsePDU(),
                                          event.getStateReference(),
                                          new StatusInformation());
    }
  }

}