/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. * * @param type the TransportEvent type * @param validSent valid addresses to which message was sent * @param validUnsent valid addresses to which message was not sent * @param invalid the invalid addresses * @param msg the message */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. * * @param type the TransportEvent type * @param validSent valid addresses to which message was sent * @param validUnsent valid addresses to which message was not sent * @param invalid the invalid addresses * @param msg the message */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message message) { queueEvent(new TransportEvent(this, type, validSent, validUnsent, invalid, message), transportListeners); } }
protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message message) { queueEvent(new TransportEvent(this, type, validSent, validUnsent, invalid, message), transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. * * @param type the TransportEvent type * @param validSent valid addresses to which message was sent * @param validUnsent valid addresses to which message was not sent * @param invalid the invalid addresses * @param msg the message */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. * * @param type the TransportEvent type * @param validSent valid addresses to which message was sent * @param validUnsent valid addresses to which message was not sent * @param invalid the invalid addresses * @param msg the message */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. * * @param type the TransportEvent type * @param validSent valid addresses to which message was sent * @param validUnsent valid addresses to which message was not sent * @param invalid the invalid addresses * @param msg the message */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. * * @param type the TransportEvent type * @param validSent valid addresses to which message was sent * @param validUnsent valid addresses to which message was not sent * @param invalid the invalid addresses * @param msg the message */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. * * @param type the TransportEvent type * @param validSent valid addresses to which message was sent * @param validUnsent valid addresses to which message was not sent * @param invalid the invalid addresses * @param msg the message */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }
/** * Notify all TransportListeners. Transport implementations are * expected to use this method to broadcast TransportEvents.<p> * * The provided default implementation queues the event into * an internal event queue. An event dispatcher thread dequeues * events from the queue and dispatches them to the registered * TransportListeners. Note that the event dispatching occurs * in a separate thread, thus avoiding potential deadlock problems. * * @param type the TransportEvent type * @param validSent valid addresses to which message was sent * @param validUnsent valid addresses to which message was not sent * @param invalid the invalid addresses * @param msg the message */ protected void notifyTransportListeners(int type, Address[] validSent, Address[] validUnsent, Address[] invalid, Message msg) { if (transportListeners == null) return; TransportEvent e = new TransportEvent(this, type, validSent, validUnsent, invalid, msg); queueEvent(e, transportListeners); } }