folder.java

java Email you can use it to send email to others

    /**
     * Notify all ConnectionListeners. Folder implementations are
     * expected to use this method to broadcast connection events. <p>
     *
     * The provided implementation queues the event into
     * an internal event queue. An event dispatcher thread dequeues
     * events from the queue and dispatches them to the registered
     * ConnectionListeners. Note that the event dispatching occurs
     * in a separate thread, thus avoiding potential deadlock problems.
     *
     * @param type	the ConnectionEvent type
     * @see		javax.mail.event.ConnectionEvent
     */
    protected void notifyConnectionListeners(int type) {
   	if (connectionListeners != null) {
	    ConnectionEvent e = new ConnectionEvent(this, type);
	    queueEvent(e, connectionListeners);
	}

	/* Fix for broken JDK1.1.x Garbage collector :
	 *  The 'conservative' GC in JDK1.1.x occasionally fails to
	 *  garbage-collect Threads which are in the wait state.
	 *  This would result in thread (and consequently memory) leaks.
	 * 
	 * We attempt to fix this by sending a 'terminator' event
	 * to the queue, after we've sent the CLOSED event. The
	 * terminator event causes the event-dispatching thread to
	 * self destruct.
	 */
	if (type == ConnectionEvent.CLOSED)
	    terminateQueue();
    }

    // Vector of folder listeners
    private volatile Vector folderListeners = null;

    /**
     * Add a listener for Folder events on this Folder. <p>
     *
     * The implementation provided here adds this listener
     * to an internal list of FolderListeners.
     *
     * @param l 	the Listener for Folder events
     * @see		javax.mail.event.FolderEvent
     */
    public synchronized void addFolderListener(FolderListener l) { 
   	if (folderListeners == null)
	    folderListeners = new Vector();
	folderListeners.addElement(l);
    }

    /**
     * Remove a Folder event listener. <p>
     *
     * The implementation provided here removes this listener
     * from the internal list of FolderListeners.
     *
     * @param l 	the listener
     * @see		#addFolderListener
     */
    public synchronized void removeFolderListener(FolderListener l) {
	if (folderListeners != null)
	    folderListeners.removeElement(l);
    }

    /**
     * Notify all FolderListeners registered on this Folder and
     * this folder's Store. Folder implementations are expected
     * to use this method to broadcast Folder events. <p>
     *
     * The implementation provided here queues the event into
     * an internal event queue. An event dispatcher thread dequeues
     * events from the queue and dispatches them to the 
     * FolderListeners registered on this folder. The implementation
     * also invokes <code>notifyFolderListeners</code> on this folder's
     * Store to notify any FolderListeners registered on the store.
     *
     * @param type	type of FolderEvent
     * @see		#notifyFolderRenamedListeners
     */
    protected void notifyFolderListeners(int type) { 
   	if (folderListeners != null) {
	    FolderEvent e = new FolderEvent(this, this, type);
	    queueEvent(e, folderListeners);
	}
	store.notifyFolderListeners(type, this);
    }

    /**
     * Notify all FolderListeners registered on this Folder and
     * this folder's Store about the renaming of this folder.
     * Folder implementations are expected to use this method to
     * broadcast Folder events indicating the renaming of folders. <p>
     *
     * The implementation provided here queues the event into
     * an internal event queue. An event dispatcher thread dequeues
     * events from the queue and dispatches them to the 
     * FolderListeners registered on this folder. The implementation
     * also invokes <code>notifyFolderRenamedListeners</code> on this 
     * folder's Store to notify any FolderListeners registered on the store.
     *
     * @param	folder	Folder representing the new name.
     * @see		#notifyFolderListeners
     * @since		JavaMail 1.1
     */
    protected void notifyFolderRenamedListeners(Folder folder) {
   	if (folderListeners != null) {
	    FolderEvent e = new FolderEvent(this, this, folder,
					    FolderEvent.RENAMED);
	    queueEvent(e, folderListeners);
	}
	store.notifyFolderRenamedListeners(this, folder);
    }

    // Vector of MessageCount listeners
    private volatile Vector messageCountListeners = null;

    /**
     * Add a listener for MessageCount events on this Folder. <p>
     *
     * The implementation provided here adds this listener
     * to an internal list of MessageCountListeners.
     *
     * @param l 	the Listener for MessageCount events
     * @see		javax.mail.event.MessageCountEvent
     */
    public synchronized void addMessageCountListener(MessageCountListener l) { 
   	if (messageCountListeners == null)
	    messageCountListeners = new Vector();
	messageCountListeners.addElement(l);
    }

    /**
     * Remove a MessageCount listener. <p>
     *
     * The implementation provided here removes this listener
     * from the internal list of MessageCountListeners.
     *
     * @param l 	the listener
     * @see		#addMessageCountListener
     */
    public synchronized void
			removeMessageCountListener(MessageCountListener l) { 
   	if (messageCountListeners != null) 
	    messageCountListeners.removeElement(l); 
    }

    /**
     * Notify all MessageCountListeners about the addition of messages
     * into this folder. Folder implementations are expected to use this 
     * method to broadcast MessageCount events for indicating arrival of
     * new messages. <p>
     *
     * The provided implementation queues the event into
     * an internal event queue. An event dispatcher thread dequeues
     * events from the queue and dispatches them to the registered
     * MessageCountListeners. Note that the event dispatching occurs
     * in a separate thread, thus avoiding potential deadlock problems.
     */
    protected void notifyMessageAddedListeners(Message[] msgs) { 
   	if (messageCountListeners == null)
	    return;

	MessageCountEvent e = new MessageCountEvent(
					this, 
					MessageCountEvent.ADDED, 
					false,
					msgs);

   	queueEvent(e, messageCountListeners); 
    }

    /**
     * Notify all MessageCountListeners about the removal of messages
     * from this Folder. Folder implementations are expected to use this 
     * method to broadcast MessageCount events indicating removal of
     * messages. <p>
     *
     * The provided implementation queues the event into
     * an internal event queue. An event dispatcher thread dequeues
     * events from the queue and dispatches them to the registered
     * MessageCountListeners. Note that the event dispatching occurs
     * in a separate thread, thus avoiding potential deadlock problems.
     */
    protected void notifyMessageRemovedListeners(boolean removed, 
						 Message[] msgs) { 
   	if (messageCountListeners == null)
	    return;

	MessageCountEvent e = new MessageCountEvent(
					this, 
					MessageCountEvent.REMOVED, 
					removed,
					msgs);
   	queueEvent(e, messageCountListeners); 
    }

    // Vector of MessageChanged listeners.
    private volatile Vector messageChangedListeners = null;

    /**
     * Add a listener for MessageChanged events on this Folder. <p>
     *
     * The implementation provided here adds this listener
     * to an internal list of MessageChangedListeners.
     *
     * @param l 	the Listener for MessageChanged events
     * @see		javax.mail.event.MessageChangedEvent
     */
    public synchronized void
			addMessageChangedListener(MessageChangedListener l) { 
   	if (messageChangedListeners == null)
	    messageChangedListeners = new Vector();
	messageChangedListeners.addElement(l);
    }

    /**
     * Remove a MessageChanged listener. <p>
     *
     * The implementation provided here removes this listener
     * from the internal list of MessageChangedListeners.
     *
     * @param l 	the listener
     * @see		#addMessageChangedListener
     */
    public synchronized void
		removeMessageChangedListener(MessageChangedListener l) { 
   	if (messageChangedListeners != null) 
	    messageChangedListeners.removeElement(l);
    }

    /**
     * Notify all MessageChangedListeners. Folder implementations are
     * expected to use this method to broadcast MessageChanged events. <p>
     *
     * The provided implementation queues the event into
     * an internal event queue. An event dispatcher thread dequeues
     * events from the queue and dispatches them to registered
     * MessageChangedListeners. Note that the event dispatching occurs
     * in a separate thread, thus avoiding potential deadlock problems.
     */
    protected void notifyMessageChangedListeners(int type, Message msg) {
	if (messageChangedListeners == null)
	    return;
	
	MessageChangedEvent e = new MessageChangedEvent(this, type, msg);
	queueEvent(e, messageChangedListeners);
    }

    /*
     * The queue of events to be delivered.
     */
    private EventQueue q;

    /*
     * A lock for creating the EventQueue object.  Only one thread should
     * create an EventQueue for this folder.  We can't synchronize on the
     * folder's lock because that would violate the locking hierarchy in
     * some cases.  For details, see the IMAP provider.
     */
    private Object qLock = new Object();

    /*
     * Add the event and vector of listeners to the queue to be delivered.
     */
    private void queueEvent(MailEvent event, Vector vector) {
	// synchronize creation of the event queue
	synchronized (qLock) {
	    if (q == null)
		q = new EventQueue();
	}

	/*
         * Copy the vector in order to freeze the state of the set
         * of EventListeners the event should be delivered to prior
         * to delivery.  This ensures that any changes made to the
         * Vector from a target listener's method during the delivery
         * of this event will not take effect until after the event is
         * delivered.
         */
	Vector v = (Vector)vector.clone();
	q.enqueue(event, v);
    }

    static class TerminatorEvent extends MailEvent {
	private static final long serialVersionUID = 3765761925441296565L;

	TerminatorEvent() {
	    super(new Object());
	}

	public void dispatch(Object listener) {
	    // Kill the event dispatching thread.
	    Thread.currentThread().interrupt();
	}
    }

    // Dispatch the terminator
    private void terminateQueue() {
	synchronized (qLock) {
	    if (q != null) {
		Vector dummyListeners = new Vector();
		dummyListeners.setSize(1); // need atleast one listener
		q.enqueue(new TerminatorEvent(), dummyListeners);
		q = null;
	    }
	}
    }

    protected void finalize() throws Throwable {
	super.finalize();
	terminateQueue();
    }

    /**
     * override the default toString(), it will return the String
     * from Folder.getFullName() or if that is null, it will use
     * the default toString() behavior.
     */

    public String toString() {
	String s = getFullName();
	if (s != null)
	    return s;
	else
	    return super.toString();
    }
}