messageindex.java

mywork是rcp开发的很好的例子

		if (dataDirectory.exists()) {
			String files[] = dataDirectory.list(
				new FilenameFilter() {
					public boolean accept(File dir, String name) {
						if (name.endsWith(DATA_FILE_SUFFIX) && ! name.equals(POP3Store.UIDL_FILENAME)) {
							return true;
						}
						return false;
					}
				});
			if (files != null) {
				for (int i = 0; i < files.length; ++i) {
					MessageIndexElement mie = new MessageIndexElement();
					mie.setFileName(files[i]);
					elements.addElement(mie);
				}
			}
			if ( elements.size() > 1) {
				saverThread.enqueue(this);
			}
		}
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @return	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	protected synchronized File createMessageFile() {
		long currentTime = System.currentTimeMillis();
		File file = null;
		do {
			file = new File(dataDirectory, Long.toHexString(currentTime) + DATA_FILE_SUFFIX);
			currentTime++;
		} while (file.exists());

		return file;
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @param	message	ꆼꆼꆼꆼꆼ.
	 * @param	flags	ꆼꆼꆼ.
	 */
	public synchronized void setFlags(POP3Message message, Flags flags) {
		MessageIndexElement elem = (MessageIndexElement) message.getInternalID();
		elem.setFlags(flags);
		saverThread.enqueue(this);
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @param	message	ꆼꆼꆼꆼꆼ.
	 * @return	ꆼꆼꆼ.
	 */
	public synchronized Flags getFlags(POP3Message message) {
		MessageIndexElement elem = (MessageIndexElement) message.getInternalID();
		return elem.getFlags();
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @return	ꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	public synchronized int getNewMessageCount() {
		int count = 0;
		for (int i = 1; i < elements.size(); ++i) {
			MessageIndexElement elem = (MessageIndexElement) elements.elementAt(i);
			if (elem.getFlags().contains(Flags.Flag.RECENT)) {
				count++;
			}
		}
		return count;
	}
	
	/**
	 * RECENTꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
	 */
	synchronized void clearRecentFlag() {
		for (int i = 1; i < elements.size(); ++i) {
			MessageIndexElement elem = (MessageIndexElement) elements.elementAt(i);
			elem.removeFlag(Flags.Flag.RECENT);
		}
		saverThread.enqueue(this);
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @return	ꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	public synchronized int getUnreadMessageCount() {
		int count = 0;
		for (int i = 1; i < elements.size(); ++i) {
			MessageIndexElement elem = (MessageIndexElement) elements.elementAt(i);
			if (! elem.getFlags().contains(Flags.Flag.SEEN)) {
				count++;
			}
		}
		return count;
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	static class SaverThread extends Thread {
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		private Vector waitingQueue = new Vector();
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ NORM_PRIORITY + 1 ꆼdaemonꆼꆼꆼꆼꆼꆼꆼ.
		 */
		SaverThread() {
			setDaemon(true);
			setPriority(Thread.NORM_PRIORITY + 1);
		}
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼ MessageIndex ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ MessageIndex ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *
		 * @param	index	ꆼꆼꆼꆼꆼꆼꆼMessageIndex.
		 */
		void enqueue(MessageIndex index) {
			synchronized (waitingQueue) {
				if (! waitingQueue.contains(index)) {
					waitingQueue.addElement(index);
					waitingQueue.notify();
				}
			}
		}
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 *
		 * @exception	java.io.IOException	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		 */
		void saveAllIndexes() throws IOException {
			synchronized (waitingQueue) {
				Enumeration e = waitingQueue.elements();
				while (e.hasMoreElements()) {
					MessageIndex index = (MessageIndex) e.nextElement();
					index.save();
				}
				waitingQueue.removeAllElements();
			}
		}
		
		/**
		 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼMessageIndexꆼꆼꆼꆼꆼ.
		 */
		public void run() {
			try {
				while (true) {
					MessageIndex index = null;
					synchronized (waitingQueue) {
						while (waitingQueue.isEmpty()) {
							waitingQueue.wait();
						}
						index = (MessageIndex)waitingQueue.firstElement();
						waitingQueue.removeElement(index);
					}
					if (index != null) {
						try {
							index.save();
						} catch (IOException ioe) {
							ioe.printStackTrace();
						}
					}
				}
			} catch (InterruptedException ie) {
				ie.printStackTrace();
			}
		}
	}

	public static HashMap getHEADERS_MAP() {
		return HEADERS_MAP;
	}
	public static HashMap setHEADERS_MAP(HashMap map) {
		return HEADERS_MAP=map;
	}

	public static boolean isCacheContent() {
		return cacheContent;
	}

	public static void setCacheContent(boolean cached) {
		cacheContent = cached;
	}
	
}

/**
 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
 *
 * @author FreeBeans &lt;<A HREF="mailto:[e-mail]">mailto:[e-mail]</A>&gt;
 * @version 0.8.6
 */
class MessageIndexElement implements Serializable {
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.ꆼꆼꆼꆼꆼꆼꆼ.
	 */
	static final long serialVersionUID = -8416233115769537346L;

	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	private String filename;
	
	/**
	 * ꆼꆼꆼꆼꆼꆼ Flags.
	 * ꆼꆼ Flags ꆼ Serializable ꆼꆼꆼꆼꆼꆼꆼ
	 * readObject()/writeObject() ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	private transient Flags flags = new Flags();
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * readObject()/writeObject() ꆼꆼꆼꆼꆼꆼꆼ.
	 */
	private static final int ANSWERED_BIT =  1;
	private static final int DELETED_BIT  =  2;
	private static final int DRAFT_BIT    =  4;
	private static final int FLAGGED_BIT  =  8;
	private static final int RECENT_BIT   = 16;
	private static final int SEEN_BIT     = 32;
	private static final int USER_BIT     = 64;
	
	/**
	 * @serial	ꆼꆼꆼꆼꆼꆼꆼ.
	 */
	private int systemFlags;
	
	/**
	 * @serial	ꆼꆼꆼꆼꆼꆼ.
	 */
	private String[] userFlags;
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	public MessageIndexElement() {
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
	 * MessageIndexElement ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	public MessageIndexElement(String filename) {
		this.filename = filename;
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @param	filename	ꆼꆼꆼꆼꆼ.
	 */
	public synchronized void setFileName(String filename) {
		this.filename = filename;
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @return	ꆼꆼꆼꆼꆼ.
	 */
	public synchronized String getFileName() {
		return filename;
	}
	
	/**
	 * Flags ꆼꆼꆼꆼꆼ.
	 *
	 * @param	flags
	 */
	public synchronized void setFlags(Flags flags) {
		this.flags = (Flags) flags.clone();
	}
	
	/**
	 * ꆼꆼꆼꆼꆼFlagꆼꆼꆼꆼꆼꆼ
	 */
	public synchronized void removeFlag(Flags.Flag flag) {
		this.flags.remove(flag);
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @return	ꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	public synchronized Flags getFlags() {
		return (Flags) flags.clone();
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @param	directory	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * @return	ꆼꆼꆼꆼꆼꆼꆼ.
	 * @exception	java.io.IOException	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	public synchronized InputStream getInputStream(File directory) throws IOException {
		File file = new File(directory, getFileName());
		return new FileInputStream(file);
		// FileNotFoundException ꆼ catch ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
		// InputStream ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @param	directory	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * @return	ꆼꆼꆼꆼꆼꆼꆼ.
	 * @exception	java.io.IOException	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	public synchronized OutputStream getOutputStream(File directory) throws IOException {
		return new FileOutputStream(new File(directory, getFileName()));
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @param	directory	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * @return	ꆼꆼꆼꆼꆼꆼꆼꆼꆼ true.
	 */
	public synchronized boolean delete(File directory) {
		File file = new File(directory, getFileName());
		return file.delete();
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 *
	 * @param	stream	ꆼꆼꆼꆼꆼꆼꆼ.
	 * @exception	java.io.IOException	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 * @exception	java.io.ClassNotFoundException	ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
		stream.defaultReadObject();
		flags = new Flags();
		// ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼflags ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		if ((systemFlags & ANSWERED_BIT) != 0) {
			flags.add(Flags.Flag.ANSWERED);
		}
		if ((systemFlags & DELETED_BIT) != 0) {
			flags.add(Flags.Flag.DELETED);
		}
		if ((systemFlags & DRAFT_BIT) != 0) {
			flags.add(Flags.Flag.DRAFT);
		}
		if ((systemFlags & FLAGGED_BIT) != 0) {
			flags.add(Flags.Flag.FLAGGED);
		}
		if ((systemFlags & RECENT_BIT) != 0) {
			flags.add(Flags.Flag.RECENT);
		}
		if ((systemFlags & SEEN_BIT) != 0) {
			flags.add(Flags.Flag.SEEN);
		}
		if ((systemFlags & USER_BIT) != 0) {
			flags.add(Flags.Flag.USER);
		}
		if (userFlags != null) {
			for (int i = 0; i < userFlags.length; ++i) {
				flags.add(userFlags[i]);
			}
		}
	}
	
	/**
	 * ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
	 */
	private void writeObject(ObjectOutputStream stream) throws IOException {
		// ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		systemFlags = 0;
		if (flags != null) {
			Flags.Flag flgs[] = flags.getSystemFlags();
			for (int i = 0; i < flgs.length; ++i) {
				if (flgs[i] == Flags.Flag.ANSWERED) {
					systemFlags |= ANSWERED_BIT;
				} else if (flgs[i] == Flags.Flag.DELETED) {
					systemFlags |= DELETED_BIT;
				} else if (flgs[i] == Flags.Flag.DRAFT) {
					systemFlags |= DRAFT_BIT;
				} else if (flgs[i] == Flags.Flag.FLAGGED) {
					systemFlags |= FLAGGED_BIT;
				} else if (flgs[i] == Flags.Flag.RECENT) {
					systemFlags |= RECENT_BIT;
				} else if (flgs[i] == Flags.Flag.SEEN) {
					systemFlags |= SEEN_BIT;
				} else if (flgs[i] == Flags.Flag.USER) {
					systemFlags |= USER_BIT;
				}
			}
		}
		
		// ꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼꆼ.
		userFlags = flags.getUserFlags();
		stream.defaultWriteObject();
	}
}