Notes on the Project

This is a short collection of notes on the project, primarily copied from selected outlines.

• From Outline 9
  • Project Components
  • A Mailbox Class
    • Using the Mailbox Class
• From Outline 14
  • Initial Architectural Diagram
  • Short Notes
  • Project Components

From Outline 9

Project Components

• As we begin to build our mail client, we need to think about the various classes and objects that will make up its components.
• Our client will need to talk to two kinds of servers:
  • A ``mail storage server'' holds users' mail messages.
  • A ``outgoing mail server'' accepts new messages (which it may convey to the local mail storage server or send out on the Internet).
• Since both of those servers are already in place, we simply need to design objects that can talk to them.
  • A Mailbox talks to the mail storage server.
  • A Sender talks to the outgoing mail server.
• By designing such objects, we simplify the rest of our program: nothing else needs to know how to communicate with servers; other objects need only use the ``server objects''.
• Often, we'll want to move the messages into different Folders.
  • We need a main folder, which we might call the inbox.
  • We'll need a special trash folder.
  • Users might create others.
• Before displaying messages in a folder, one might want to use a Sorter to organize them or a Filter to select only some,
• We will create user interfaces for all of these parts.
  • A textual user interface might serve as a substitute for dreams or pine.
  • A graphical user interface will serve as the replacement for everything else.
• We still need to decide what objects belong to each interface.
• We will use a Composer to compose new messages.
• We may want an AddressBook class (which may somehow communicate with the address book on the server).
• We may want a FaceBook class so that we can display peoples' pictures when we receive messages from them.
• I'm sure we'll come up with others.

A Mailbox Class

• For today, we'll consider the simplest possible design of the Mailbox class. What methods should that class provide?
• We've decided that it makes sense to provide an account and a password when we first create a Mailbox. That way, we get the mailbox for a particular person. We also handle the question of how to get the password and account to the class.

  public Mailbox(String account, String password) { ... }
  

• We've decided to allow the client to get lists of messages from the server. These lists will include sender, subject, date, and message-id for each message. (Later, we may decide on more.)

  public MessageInfoList listMessages() { ... }
  

• Once the client has a list of messages, it needs to be able to get individual messages.

  public MailMessage getMessage(String messageID) { ... }
  

• The client may also delete messages.

  public void deleteMessage(String messageID) { ... }
  

• Finally, we realized that it's important to check for errors. (What if we tried to create the mailbox with an illegal account or password?)

  public void isValid() { ... }
  

  • Next Wednesday, we'll find a more elegant wway to do this.
• Putting it all together ...

  
  import MailMessage;
  import MessageInfoList;
  
  /**
   * A simple implementation of mailboxes (one that doesn't really work).
   * Created as an example for CSC152 99F.
   *
   * @author Samuel A. Rebelsky
   * @author The students of CSC152 99F
   * @version 1.0 of September 1999
   */
  public class Mailbox {
    // +--------------+--------------------------------------------
    // | Constructors |
    // +--------------+
  
    /** 
     * Create a new mailbox for a particular user.  Requires the
     * account and password for obvious reasons.
     */
    public Mailbox(String account, String password) {
      // ...
    } // Mailbox(String, String)
  
    // +---------+-------------------------------------------------
    // | Methods |
    // +---------+
  
    /** List all the messages in the mailbox. */
    public MessageInfoList listMessages() {
      return new MessageInfoList(); // STUB
    } // listMessages()
  
    /** Get one message. */
    public MailMessage getMessage(String messageID) {
      return new MailMessage(); // STUB
    } // getMessage(String)
  
    /** Delete a message. */
    public void deleteMessage(String messageID) {
      return; // STUB
    } // deleteMessage(String)
  
    /** Check if the mailbox is valid. */
    public boolean isValid() {
      return true; // STUB
    } // isValid()
  } // class Mailbox
  
  
  
  

• While there are other features we might add, we'll leave those until later.

Using the Mailbox Class

• Now that we've described the functionality of the class, we can start to use the class. (Someone else will be responsible for implementing the class.)
• Suppose we want to print out all someone's messages. What might our program look like?

  
  import Mailbox;
  import MailMessage;
  import MessageInfoList;
  import SimpleInput;
  import SimpleOutput;
  
  /**
   * A simple controlling class to print out the contents of a
   * user's mailbox.
   *
   * @author Samuel A. Rebelsky
   * @author The Students of CSC152 99S
   * @version 1.0 of September 1999
   */
  public class MailDumper {
    public static void main(String[] args) {
      // Prepare for input and output.
      SimpleInput eyes = new SimpleInput();
      SimpleOutput pen = new SimpleOutput();
      // Other necessary variables.
      String account;    // The user's account.
      String password;   // The user's password.
      Mailbox mail;      // The mailbox we create.
      MessageInfoList messages;
                         // A list of messages in that mailbox.
      MailMessage msg;   // One mail message.
  
      // 1. Get the account and password.  Note that we eventually
      // need to update this so that the password is not visible.
      pen.print("Account: "); 
      account = eyes.readString();
      pen.print("Password: "); 
      password = eyes.readString();
  
      // 2. Create the mailbox.
      mail = new Mailbox(account, password);
  
      // 3. Ensure that the mailbox was correctly created.  If not,
      // crash and burn, but in a friendly way.
      // ...
  
      // 4. Get the list of messages
      // ...
  
      // 5. For each message in that list
      // ...
         // a. Get the full message
         // ...
         // b. Print it out
         pen.println(msg.toString());
  
    } // main(String[] args)
  } // class MailDumper
  
  
  
  

From Outline 14

Initial Architectural Diagram

                           +----------+
                    +------| Maildrop |----+ +-------------+
                    |      +----------+  +-+-| Text Client |
+---------+   +---------+   +---------+  | | +-------------+
| Servers |---| Network |---| Mailbox |--+ |              |
+---------+   +---------+   +---------+  | | +-----+      |
                                 |       +-+-| GUI |      |
     +-------------+        +---------+      +-----+   +--------+
     | MailMessage |        | Folders |       | \------| Filter |
     +-------------+        +---------+       |        +--------+
                                              |
     +-------------+  +-------+      +---------------+
     | MsgInfoList |  | Prefs |      | Face Database |
     +-------------+  +-------+      +---------------+

Short Notes

• We're not responsible for the servers; just for connecting to and using them with existing protocols (IMAP, whatever Microsoft uses for its extended functionality).
• MailMessage, MsgInfoList, and Prefs are utility classes that will be shared by many of the other classes (or groups of classes).
• The GUI will necessarily have many pieces, including
  • An overview window
  • Composing windows
  • Message reading windows
  • Filter interface windows
  • ...

Project Components

We will eventually segment to project into reasonable-size parts. Here are my initial categories. See the list of teams and their projects for more information on each subproject.

• Network
• Mailbox plus Maildrop
• Message composer
• Filters (including prioritization)
• Textual interface
• Graphical interface (no Message composer)
• Face database