Changeset 259

Timestamp:

08/01/08 10:18:16 PM (4 months ago)

Author:

octorian

Message:

Mailbox node serialization

Location:

trunk/LogicMail/src/org/logicprobe/LogicMail

Files:

• mail/AbstractMailStore.java (modified) (1 diff)
• mail/FolderTreeItem.java (modified) (1 diff)
• mail/imap/ImapClient.java (modified) (2 diffs)
• mail/IncomingMailClient.java (modified) (1 diff)
• mail/IncomingMailConnectionHandler.java (modified) (2 diffs)
• mail/NetworkMailStore.java (modified) (2 diffs)
• mail/pop/PopClient.java (modified) (1 diff)
• model/AccountNode.java (modified) (9 diffs)
• model/MailboxNode.java (modified) (6 diffs)
• model/MailManager.java (modified) (1 diff)

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/AbstractMailStore.java

@@ -112 +112 @@
     
     /**
-     * Requests the current message counts of a folder or
-     * group of folders.
-     * 
-     * <p>Successful completion is indicated by a call to
+     * Requests the current message counts of a group of folders.
+     * 
+     * <p>Successful completion is indicated by calls to
      * {@link FolderListener#folderStatusChanged(FolderEvent)}.
      * 
-     * @param root The root node of the folder tree to refresh.
-     */
-    public abstract void requestFolderStatus(FolderTreeItem root);
+     * @param folders The folder tree items to refresh.
+     */
+    public abstract void requestFolderStatus(FolderTreeItem[] folders);
     
     /**

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/FolderTreeItem.java

@@ -91 +91 @@
     
     /**
+     * Create a folder tree item that is a clone of the source item,
+     * but has none of the references to parent or children items.
+     * 
+     * @param source The source item.
+     */
+    public FolderTreeItem(FolderTreeItem source) {
+        this.uniqueId = UniqueIdGenerator.getInstance().getUniqueId();
+        this.name = source.name;
+        this.path = source.path;
+        this.delim = source.delim;
+        this.selectable = source.selectable;
+        this.msgCount = source.msgCount;
+        this.unseenCount = source.unseenCount;
+    }
+    
+    /**
      * Creates an uninitialized folder tree item.
      * Only for use during deserialization.

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapClient.java

@@ -325 +325 @@
         }
 
-    public void refreshFolderStatus(FolderTreeItem root) throws IOException, MailException {
-        // Flatten the tree for easy batching of the status refresh
-        Vector folders = new Vector();
-        flattenFolderTree(folders, root);
-        
+    public void refreshFolderStatus(FolderTreeItem[] folders) throws IOException, MailException {
         // Construct an array of mailbox paths to match the folder vector
-        int size = folders.size();
         Vector mboxPaths = new Vector();
         Hashtable mboxMap = new Hashtable();
         int i;
-        for(i=0; i<size; i++) {
-            FolderTreeItem item = (FolderTreeItem)folders.elementAt(i);
+        for(i=0; i<folders.length; i++) {
+            FolderTreeItem item = folders[i];
             if(item.isSelectable()) {
                 mboxPaths.addElement(item.getPath());
@@ -355 +350 @@
         }
     }
-    
-    /**
-     * Recursively walk the folder tree, populating a flat vector of
-     * FolderTreeItem objects.
-     *
-     * @param folders An initialized Vector to populate
-     * @param node The FolderTreeItem to start from
-     */
-    private void flattenFolderTree(Vector folders, FolderTreeItem node) {
-        // Avoid adding the invisible root node
-        if(node.getPath().length() > 0) {
-            folders.addElement(node);
-        }
-        
-        if(node.hasChildren()) {
-            FolderTreeItem[] children = node.children();
-            for(int i = 0; i < children.length; i++) {
-                flattenFolderTree(folders, children[i]);
-            }
-        }
-    }
-    
     
     public FolderTreeItem getActiveFolder() {

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/IncomingMailClient.java

@@ -84 +84 @@
     
     /**
-     * Refresh the folder status across the folder tree.
+     * Refresh the folder status.
      *
-     * @param root The root of the folder tree
+     * @param folders The folders to refresh
      * @throw IOException on I/O errors
      * @throw MailException on protocol errors
      */
-    public abstract void refreshFolderStatus(FolderTreeItem root)
+    public abstract void refreshFolderStatus(FolderTreeItem[] folders)
         throws IOException, MailException;
     

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/IncomingMailConnectionHandler.java

@@ -75 +75 @@
                         break;
                 case REQUEST_FOLDER_STATUS:
-                        handleRequestFolderStatus((FolderTreeItem)params[0]);
+                        handleRequestFolderStatus((FolderTreeItem[])params[0]);
                         break;
                 case REQUEST_FOLDER_MESSAGES_RANGE:
@@ -126 +126 @@
         }
         
-        private void handleRequestFolderStatus(FolderTreeItem root) throws IOException, MailException {
-                incomingClient.refreshFolderStatus(root);
-                
-                MailConnectionHandlerListener listener = getListener();
-                if(listener != null) {
-                        listener.mailConnectionRequestComplete(REQUEST_FOLDER_STATUS, root);
+        private void handleRequestFolderStatus(FolderTreeItem[] folders) throws IOException, MailException {
+                incomingClient.refreshFolderStatus(folders);
+                
+                MailConnectionHandlerListener listener = getListener();
+                if(listener != null) {
+                        listener.mailConnectionRequestComplete(REQUEST_FOLDER_STATUS, folders);
                 }
         }

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/NetworkMailStore.java

@@ -109 +109 @@
         }
 
-        public void requestFolderStatus(FolderTreeItem root) {
-                connectionHandler.addRequest(IncomingMailConnectionHandler.REQUEST_FOLDER_STATUS, new Object[] { root });
+        public void requestFolderStatus(FolderTreeItem[] folders) {
+                connectionHandler.addRequest(IncomingMailConnectionHandler.REQUEST_FOLDER_STATUS, new Object[] { folders });
         }
 
@@ -165 +165 @@
                         break;
                 case IncomingMailConnectionHandler.REQUEST_FOLDER_STATUS:
-                        fireFolderStatusChanged((FolderTreeItem)result);
+                        FolderTreeItem[] folders = (FolderTreeItem[])result;
+                        for(int i=0; i<folders.length; i++) {
+                                fireFolderStatusChanged(folders[i]);
+                        }
                         break;
                 case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RANGE:

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/pop/PopClient.java

@@ -214 +214 @@
     }
 
-    public void refreshFolderStatus(FolderTreeItem root) throws IOException, MailException {
+    public void refreshFolderStatus(FolderTreeItem[] folders) throws IOException, MailException {
         // Only one mailbox can exist, so we just pull the message counts
         activeMailbox.setMsgCount(popProtocol.executeStat());
+        if(folders.length == 1 && folders[0] != activeMailbox) {
+                folders[0].setMsgCount(activeMailbox.getMsgCount());
+        }
     }
 

trunk/LogicMail/src/org/logicprobe/LogicMail/model/AccountNode.java

@@ -31 +31 @@
 package org.logicprobe.LogicMail.model;
 
+import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Vector;
@@ -51 +52 @@
 import org.logicprobe.LogicMail.message.Message;
 import org.logicprobe.LogicMail.message.MessageFlags;
+import org.logicprobe.LogicMail.util.DataStore;
+import org.logicprobe.LogicMail.util.DataStoreFactory;
 import org.logicprobe.LogicMail.util.EventListenerList;
 
@@ -74 +77 @@
         private Vector outboundNewMessages = new Vector();
         private Hashtable outboundMessageReplies = new Hashtable(); 
-        
+        private DataStore accountDataStore;
+
         public final static int STATUS_LOCAL   = 0;
         public final static int STATUS_OFFLINE = 1;
@@ -132 +136 @@
                         // Create the fake INBOX node for non-folder-capable mail stores
                         this.rootMailbox = new MailboxNode(new FolderTreeItem("", "", ""), -1);
+                        this.rootMailbox.setParentAccount(this);
                         MailboxNode inboxNode = new MailboxNode(new FolderTreeItem("INBOX", "INBOX", ""), MailboxNode.TYPE_INBOX);
                         inboxNode.setParentAccount(this);
@@ -137 +142 @@
                         pathMailboxMap.put("INBOX", inboxNode);
                 }
+                
+                // Load any saved tree data
+                load();
         }
         
@@ -333 +341 @@
          */
         public void refreshMailboxStatus() {
-                MailboxNode mailbox;
-                synchronized(rootMailboxLock) {
-                        mailbox = this.rootMailbox;
-                }
-                mailStore.requestFolderStatus(mailbox.getFolderTreeItem());
+                int size = pathMailboxMap.size();
+                FolderTreeItem[] folders = new FolderTreeItem[size];
+                Enumeration e = pathMailboxMap.keys();
+                for(int i=0; i<size; i++) {
+                        folders[i] = ((MailboxNode)pathMailboxMap.get(e.nextElement())).getFolderTreeItem();
+                }
+                mailStore.requestFolderStatus(folders);
         }
 
@@ -408 +418 @@
                 }
                 
+                save();
                 fireAccountStatusChanged(AccountNodeEvent.TYPE_MAILBOX_TREE);
         }
@@ -431 +442 @@
                 }
         }
-        
+
         private void populateMailboxNodes(FolderTreeItem folderTreeItem, MailboxNode currentMailbox, Hashtable remainingMailboxMap) {
                 pathMailboxMap.put(folderTreeItem.getPath(), currentMailbox);
@@ -681 +692 @@
         }
     }
+    
+    /**
+     * Saves the mailbox tree to persistent storage.
+     */
+        private void save() {
+                if(accountConfig == null) {
+                        return;
+                }
+                if(accountDataStore == null) {
+                        long accountId = accountConfig.getUniqueId();
+                        accountDataStore = DataStoreFactory.getConnectionCacheStore(accountId);
+                        accountDataStore.load();
+                }
+                
+                accountDataStore.putNamedObject("ROOT_MAILBOX", rootMailbox);
+                accountDataStore.save();
+        }
+        
+        /**
+         * Loads the mailbox tree from persistent storage.
+         */
+        private void load() {
+                if(accountConfig == null) {
+                        return;
+                }
+                if(accountDataStore == null) {
+                        long accountId = accountConfig.getUniqueId();
+                        accountDataStore = DataStoreFactory.getConnectionCacheStore(accountId);
+                        accountDataStore.load();
+                }
+
+                Object loadedObject = accountDataStore.getNamedObject("ROOT_MAILBOX");
+                if(loadedObject instanceof MailboxNode) {
+                        synchronized(rootMailboxLock) {
+                                this.rootMailbox = (MailboxNode)loadedObject;
+                                this.rootMailbox.setParentAccount(this);
+                                prepareDeserializedMailboxNode(rootMailbox);
+                        }
+                }
+        }
+        
+        //TODO: Handle deleted account nodes
+        
+        /**
+         * Traverses the deserialized mailbox nodes, populates any necessary
+         * data structures in the account node, and sets the mailbox parent
+         * account references. 
+         *
+         * @param mailboxNode The mailbox node.
+         */
+        private void prepareDeserializedMailboxNode(MailboxNode mailboxNode) {
+                mailboxNode.setParentAccount(this);
+                FolderTreeItem item = mailboxNode.getFolderTreeItem();
+                if(item != null && item.getPath().length() > 0) {
+                        this.pathMailboxMap.put(item.getPath(), mailboxNode);
+                }
+                MailboxNode[] children = mailboxNode.getMailboxes();
+                for(int i=0; i<children.length; i++) {
+                        prepareDeserializedMailboxNode(children[i]);
+                }
+        }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/model/MailboxNode.java

@@ -31 +31 @@
 package org.logicprobe.LogicMail.model;
 
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
 import java.util.Hashtable;
 import java.util.Vector;
@@ -37 +40 @@
 import org.logicprobe.LogicMail.mail.FolderTreeItem;
 import org.logicprobe.LogicMail.util.EventListenerList;
+import org.logicprobe.LogicMail.util.Serializable;
+import org.logicprobe.LogicMail.util.UniqueIdGenerator;
 
 /**
@@ -43 +48 @@
  * <tt>MessageNode</tt> instances as its children.
  */
-public class MailboxNode implements Node {
+public class MailboxNode implements Node, Serializable {
+        private long uniqueId;
         private AccountNode parentAccount;
         private MailboxNode parentMailbox;
@@ -59 +65 @@
         public final static int TYPE_TRASH  = 4;
 
+        /**
+         * Initializes a new instance of <tt>MailboxNode</tt>.
+         * 
+         * @param folderTreeItem The folder item this node wraps.
+         * @param type The type of mailbox this is representing.
+         */
         MailboxNode(FolderTreeItem folderTreeItem, int type) {
+                this.uniqueId = UniqueIdGenerator.getInstance().getUniqueId();
                 this.mailboxes = new Vector();
                 this.messages = new Vector();
                 this.messageMap = new Hashtable();
-                this.folderTreeItem = folderTreeItem;
+                if(folderTreeItem != null) {
+                        this.setFolderTreeItem(new FolderTreeItem(folderTreeItem));
+                }
                 this.type = type;
         }
         
+        /**
+         * Initializes a new instance of <tt>MailboxNode</tt>.
+         * 
+         * @param folderTreeItem The folder item this node wraps.
+         */
         MailboxNode(FolderTreeItem folderTreeItem) {
                 this(folderTreeItem, TYPE_NORMAL);
         }
         
-        MailboxNode() {
+        /**
+         * Initializes a new instance of <tt>MailboxNode</tt>.
+         * 
+         * <p><i>Note:</i> This constructor is only exposed for
+         * serialization purposes, and should never be called from
+         * outside this package for any other reason.
+         */
+        public MailboxNode() {
                 this(null, TYPE_NORMAL);
         }
@@ -121 +148 @@
          * that maintain cache data for it.
          * 
+         * <p><i>Note:</i> The actual <tt>FolderTreeItem</tt> used by this
+         * class is a deep copy of the one passed to this method.  It is
+         * implemented this way since we need a standalone object that
+         * is not part of a tree.  This is necessary to avoid excessive
+         * recursion during serialization.
+         * 
          * @param folderTreeItem Folder tree item.
          */
         void setFolderTreeItem(FolderTreeItem folderTreeItem) {
-                this.folderTreeItem = folderTreeItem;
+                this.folderTreeItem = new FolderTreeItem(folderTreeItem);
         }
         
@@ -452 +485 @@
         }
     }
+
+        public long getUniqueId() {
+                return uniqueId;
+        }
+        
+        public void serialize(DataOutputStream output) throws IOException {
+                output.writeLong(uniqueId);
+                output.writeInt(type);
+                folderTreeItem.serialize(output);
+                synchronized(mailboxes) {
+                        int size = mailboxes.size();
+                        output.writeInt(size);
+                        for(int i=0; i<size; i++) {
+                                ((MailboxNode)mailboxes.elementAt(i)).serialize(output);
+                        }
+                }
+        }
+        
+        public void deserialize(DataInputStream input) throws IOException {
+                uniqueId = input.readLong();
+                type = input.readInt();
+                folderTreeItem = new FolderTreeItem();
+                folderTreeItem.deserialize(input);
+                synchronized(mailboxes) {
+                        int size = input.readInt();
+                        for(int i=0; i<size; i++) {
+                                MailboxNode child = new MailboxNode();
+                                child.deserialize(input);
+                                child.parentMailbox = this;
+                                mailboxes.addElement(child);
+                        }
+                }
+        }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/model/MailManager.java

@@ -108 +108 @@
                 return mailRootNode;
         }
-        
-        
+
         /**
          * Called when the account configuration has changed,