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:freebeans@mub.biglobe.ne.jp">mailto:freebeans@mub.biglobe.ne.jp</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();
	}
}