messageindex.java

Eclipse RCP下编写的工作管理软件代码

			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 {
		return new FileInputStream(new File(directory, getFileName()));
		// 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();
	}
}