Project #4 Implementation Details

P4 Implementation Details

Revisions

(4/27) Output for listFriendsJournals posted. (It is similar to list).
(4/26) BNF for removeEntry added. (Note: this would affect a person's number of postings based on BRONZE, SILVER, however, there won't be any tests checking for the combination of removeEntry and BRONZE, SILVER).
(4/26) All years are now printed with 4 digits. This will make life easier (in case, you were wondering how to print with 2 digits for the years, you use the mod (i.e., % operator).
(4/25) It should say "albumTitle" in postMp3, not "album". It should say "artistName", not "artist" in postMp3.
(4/25) To make the date consistent with MP3 and journal, the date printed out for "apply" now prints years in 4 digits, and print the time of day.
(4/23) Time printed for MP3 entries, just as in journal entries. (It was left off earlier on).
(4/23) removeEntry command added. Should be straightforward to implement. Fixed up followup description.
(4/22) Mostly some wording clarifications. However, one of the buttons is now rename listFriendsJournals (be careful with all the 's' that appear in the name of the button). That's the button where you print the N most recent top-level messages of a particular person.
(4/22) Also, to show the proper indentation for followups, you will print 5k periods, instead of 5k spaces. That way, diff can tell what happened.
(4/22) Friends should be sorted by last name using string comparison. Since you are using string comparison, it will be case sensitive. If the last names are the same based on string comparison, then you should compare first names afterwards.
(4/22) Friends should be printed based on name order. They should be sorted by last names. If the last names are the same, compare first names. This should be case-sensitive (that way, you only have to compare using comparison operators provided by the string class).

Click here for older version

Some comments:

There are two kinds of widgets: TextField and Button, both of them are derived from Widget which is the base class.
The buttons and text field objects should be declared as data members of Gui. They should be private, but it is permissible to make them public. (Again, realize when you write code, favor writing it the "right" way, instead of the quick and dirty way).
An alternative to declaring a data member per text field and button is to create a SimpleMap of strings to Widget *, just as you did in the tester classes. This merely saves space. You may wish to overload the operator[] for use outside the Gui class.

. Assumptions you can make

When a button is pressed, you may assume all text fields have been set correctly.
No two names are the same.
No two aliases are the same.
No name is also an alias (which is obvious since names have first and last name)
No two entries has the same date (including the time). Thus, two entries can be posted on the same day, but have to be posted at different times.
A day is considered to be the 24 hour period of a day, e.g. April 22, 2002 (all day).

TextField objects in Gui

The following are a list of the names of TextField objects. You should add these as TextField * data members of Gui and initialize in the constructor of Gui. You may wish to write a function called trim() which removes blanks at the beginning and end of lines to help you edit the input, when you retrieve it from the TextGui object (see the header file for methods provided). Notice that most entries have possible leading or trailing blanks.

name The user enters the name on one line. The input syntax is:
<mblanks> <word> <blanks> <word> <mblanks>
That is, the user enters first and last name, and there may be blanks before and after and in the middle. Hint: use your code for Movie to "split" this apart.
You may assume no two names are the same.
alias This is the alias of the user. You may assume aliases (like names) are unique. The alias is a single word. The input syntax is:
<mblanks> <word> <mblanks>

You may assume that no two aliases are the same.
friendAlias This is the alias of a user's friend. It has the same syntax as alias.
payment The payment for the user, when applying for membership.
<mblanks> <digits> <mblanks>
You may assume the input is a positive int. You have to translate this from a string to a number (hint: see previous projects, this function may already exist).
couponType Again, some digits, representing the worth of a coupon when applying for membership. You may assume the value is non-negative int.
<mblanks> <digits> <mblanks>
hasReferral true, if applicant (user) has referral, false otherwise. Again, used for applying for membership.
<mblanks> [ "true" | "false" ] <mblanks>
yrsMember Number of years that a user has been a member already. Used in application. You may assume the value is a non-negative integer.
<mblanks> <digits> <mblanks>
date The date.
<mblanks> [ "January" | "February" | "March" | "April" | "May" | "June" | "July" | "August" | "September" | "October" | "November" | "December" ] <mblanks> <digits> "," <mblanks> <digit>{4,4} <blanks> <digit> [<digit>]? ":" <digit> <digit> <blanks> [ "AM" | "PM" ] <mblanks>
You can assume the digits are sensible for the month. You can ignore leap year. You can assume the years start in 1990 and afterwards, though it would be nice to handle a wider range of years. This is perhaps the most important field you have to manage.
Note: the comma comes immediately after the day.
This includes the day, and the time. All of this appears on one line.
Here's an example:
```
April 22, 2002   10:00 AM
```
Note that the line could contain additional blanks between locations, and at the beginning or end. However, the comma will always appear just after the day, with no space in between.
origDate The original date of a posting. Used for following up. Has the same format as date
title Title of an MP3 song, or title of the journal entry. This is for initial posting of journal entries.
<mblanks> <word> [ <blanks> <word> ] <mblanks>
duration The length of a song in minutes and seconds
<mblanks> <digits> <blanks> <digits> <mblanks>
You may assume the minutes are seconds are non-negative
albumTitle Name of album where the song appears. For MP3 postings. Same BNF as title.
artistName Name of artist for MP3. Assume it is the name of a person.
body The text printed in the body of a journal entry. This may contain more than one line.
goodFriend True or false, depending on whether friend is "good" or just so-so. The syntax is the same as hasReferral.
emoticon Associated with friend. A string of non-blank characters.
```
<mblanks> <string> <mblanks>
```
number A number. The syntax is the same as yrsMember.

Output BNF

As stated in the beginning of this webpage, you may assume when the button is pressed that the text fields have already been filled out.

The output BNF will have a similar structure to the previous projects

<output> := <line>
                    [ ["Button Pressed: (" <word> ")" <endl> <out> <line>]+ |
                      "NO BUTTONS PRESSED" <endl> <line> ]
                    <endl>

      <line> ::== "----*----*----*----*----*----*----*----*" <endl>

You should produce output only when buttons are pressed (no output when entering text fields). The first line printed indicates the button pressed. The following lines printed are indicated below. So, the first line of each output is the name of the button pressed, followed by whatever output is specified in the next section. Here's an example of the output.
----*----*----*----*----*----*----*----* Button Pressed: (apply) ....more stuff.... ----*----*----*----*----*----*----*----*
Note: you may need to modify main() to get this to work.

Buttons Specifications

The following are a list of buttons. Each button corresponds to an operation.

apply
The TextField objects used with this are:
- name
- alias
- payment
- couponType
- hasReferral
- yrsMember
- date
Use this to store information about a person. Note that these objects are strings and may have to be converted to other types for internal storage.
The output BNF for this is:
```
<out> := <name> " (" <alias> ") " has "
                [ "GOLD" | "SILVER" | "BRONZE" | "NO" ]
               " membership " as of " (" <date> ")"
<name> := <word> ", " <word> 
<date> := <digit> [<digit>]?  "/"
                <digit> [<digit>]?  "/"
                <digit> <digit>  <digit> <digit>
                "  " <digit> [<digit>]?  ":" <digit> <digit> 
                <blanks> [ "AM" | "PM" ] 
```
The name is printed last name followed by comma, space, and then the first name. The alias is the same as entered in. The date has the format that looks like "4/2/02" The year is printed as two digits. You may assume years begin after 1990 and is before, say, 2010.
(CORRECTION) (4/25) The date prints out 4 digits for the year, and also the time (the format is similar to the date for MP3 and journals).
(CLARIFICATION) Once a person has membership, you don't need to keep the information about payment, coupon type, "has referral", years member, and even the date of membership. Also, if a person didn't get membership, they can try again. Once they get membership, there won't be an attempt to change the membership.
If you want to store this information, there's no harm. Just that it's not used anywhere else.
addFriend
The TextField objects used with this are:
- alias Your alias
- friendAlias Your friend's alias
- goodFriend Whether your friend is a "good" friend or not
- emoticon The emoticon associated with your friend. Ignored if goodFriend is false.
The output BNF for this is:
```
<out2> := <name> " (" <alias> ") " 
                [ "SUCCESSFULLY ADDS" | "IS ALREADY FRIENDS WITH" ]
                <name> " (" <alias> ") " 
                [ "Emoticon: " <word> ]?
```
You may assume that the friend has already successfully been added as a member (only members may be friends). The first name and alias are your name and alias. The second name and alias are your friend's name and alias. If your friend is a "good friend", print out the emoticon too.
(CLARIFICATION) If someone is already a friend, and you add them again, you should update their emoticon (or convert to a good friend or from a good friend). This will be tested lightly (like, one secondary). Effectively, it's an update, after attempting to do an add (and having add() return false).
removeFriend
The text fields used are:
- alias Your alias
- friendAlias Your friend's alias
The output BNF for this is:
<out2> := <name> " (" <alias> ") " [ "SUCCESSFULLY REMOVES" | "IS NOT FRIENDS WITH" ] <name> " (" <alias> ") " [ "Emoticon: " <word> ]?
You may assume that friendAlias is a legitmiate alias. However, you may NOT assume that the friend is in your list of friends (thus, if you try to remove a person who is a "friend", but is not in your list, then this will return false, and you will print the "IS NOT FRIENDS WITH" message). Notice that you will have to locate your friend's real name somewhere.
If you are not friends with the person listed, then no emoticon is printed.
Hint: to handle friends, you may wish to create a Friend class that contains a Name and a GoodFriend class derived from Friend that contains the emoticon. Then, the list of friends is stored as a BST of Friend * objects.
You do not have to be very efficient about accessing friends, etc., but you may want to think about how efficient it is to find things.
listFriends
The text fields used are:
- alias Your alias
This will print a BST of friends in the tree like format from Project 3. For regular friends, print out:
<name> " (" <alias> ") "
which is last name, then first, then a space, and the alias in parentheses.
If it's a good friend, list:
```
<name> " (" <alias> ") Emoticon: " <string>
```
where the string is the emoticon
This should be printed out by comparing names.
- Compare last names using operator== for strings. If the two last names are equal (case-sensitive),
- Compare first names.
Assume that no two people have the same first AND last names, though two people could have the same first names OR the same last names.
listFriendsIn
The text fields used are:
- alias Your alias
This lists friends in inorder, just as in Project 3, where friends are printed using the syntax shown in listFriends. If there are no friends, print "EMPTY LIST", just as you did in Project 3. The output should handle regular and "good" friends.
This should be printed in NAME order.
postJournal
The text fields used are:
- alias Your alias
- date The date that the article was posted
- title The "title" of your journal entry
- body The "body" of the journal entry
When posting journal entries, you will have to be careful how many entries have been posted on that day. This will be discussed in the next section.
The output is:
```
<out> := "Journal entry for " <name> 
               [ "SUCCESSFULLY POSTED" | 
                 "NOT POSTED! Exceeds limit of " <digits> ]
```
No alias is posted. If successful, it is "posted" (i.e., recorded). If it exceeds limits, it is not posted. Limits are discussed below.
(CLARIFICATION) The limits for BRONZE is 1. For SILVER, it's 2 (2 top level posts, and 2 followups).
postMp3
The text fields used are:
- alias Your alias
- date The date that the MP3 was posted
- title The "title" of an MP3 song
- artistName The "artist" (name of a person)
- albumTitle Name of album where the song appeared
- duration How many minutes and seconds song lasts
The output is:
<out> := "MP3 for " <name> [ "SUCCESSFULLY POSTED" | "NOT POSTED! Exceeds limit of " <digits> ]
No alias is posted. If successful, it is "posted" (i.e., recorded). If it exceeds limits, it is not posted. Limits are discussed below.
(CLARIFICATION) The limits for BRONZE is 1. For SILVER, it's 2 (2 top level posts, and 2 followups).
list
The text fields are:
- alias
- number how many TOP-LEVEL journal entries/MP3 to print
This is the key display feature for a person.
The output is:
```
"Listing for " <name> " (" <alias> ")" <endl>
"====*====*====*====*====*====*====*====*" <endl>
```
Here's an example of a journal entry. How to follow up to a journal will be explained in a later section.
JOURNAL Name: Doe, John Alias: jarjar Title: "Why Economic Reform is a Joke" Date: 4/2/2002 12:20 PM Just because it is!
It has the word JOURNAL on one line, "Title:", followed by the title in double quotes on the next line, "Date: " followed by the date. Then, one blank line, and all the lines of the journal entry.
For an MP3, you have:
```
MP3
Name: Doe, John    Alias: jarjar
Title: "Eat it"
Artist: Yankovic, Al   Album: "In 3-D"   Duration: 170
Date: 4/2/2002  12:20 PM
```
You will list out the "N" most recent TOP-LEVEL entries (ignoring any followups), where "N" is specified by the <number> field. A TOP-LEVEL entry means you ignore followups when counting. Each entry should be separated from the next with one blank line. If there are fewer than "N" entries, then print the number of entries there are (both MP3 and journals). If there are zero entries, print "NO ENTRIES".
removeEntry
- alias The person who wrote the article
- date The date the article was written.
An entry can either be top level or a followup. Thus, you may have to search for the entry. When removed, all followups to that article are also removed. (This is new command). This should be relatively easy depending on how you stored the followups.
Note: in real applications, deleting a message usually does NOT delete the followup (most messages are numbered, and the followup will refer to a previous message number). However, it will be easier to remove followups to a deleted message.
The output BNF for this is:
```
<out2> := "Entry on " <date> " by " <name> " (" <alias> ") "
            [ "SUCCESSFULLY REMOVED" | "DOES NOT EXIST" ]
```
where <date> has the usual format for date (e.g., 2/7/2002).
listFriendsJournals
The text fields are:
- alias
- number how many journal entries/MP3 to print
You should print the journal entries of all friends in reverse chronological order, up to number entries. In effect, pretend all your friends had their top-level entries, sorted by date, in one big batch.
A followup is NOT considered a top level entry. A top level entry is a person who posts an MP3 or journal, and presses the postJournal or postMp3 button.
You pick the most recent N top level entries (so you ignore followups for now) where N is the value in number.
Use the same rules as list if there are too few entries or none at all.
For good friends, you should print:
```
Name: Doe, John  Emoticon: ;-)   Alias: jarjar
```
That is, add the emoticon.
This is a TOUGH function. (At least, I think it is...).
The first two lines for the output should be
```
"Listing for " <name> " (" <alias> ") friends' journals" <endl>
"====*====*====*====*====*====*====*====*" <endl>
```
After that, the output should look like list
followup
The text fields are:
- alias Your alias
- friendAlias Your friend's alias (doesn't have to be a friend, though).
- date The date you posted
- origDate The original date of the posting that you are following up to.
- title The title of your followup article. If the title is "REPLY", you should put "Re: " in front of the original article's name (unless it already has a "Re: ") in front. "Re: " means "regarding" and usually is used in follow up. If the title is anything besides REPLY, then just use the title as listed (even if it's the same as the title of the article that's being followed up. Again, don't expect this to be tested much.
- body The body of the followup article.
This is the "hardest" of the tasks to do (perhaps by far).
You will need to find a friend (actually, anyone with an alias, including yourself) and the date of the original posting. The followup For followups, you should indent 5 * K spaces in, for the followup depth. For example, if the depth is 1 (meaning first followup), you indent everything 5 spaces in. You may only followup with journal entries. You can followup on either a journal entry or an MP3, but only with a followup entry.
A followup to a follow up has a followup of depth 2. So, that would mean indent the entry 10 spaces in.
The following is an example of a followup of depth 1. It is indented 5 steps in (with 5 periods)
```
.....FOLLOWUP
.....Name: Jain, Ani  Emoticon: ;-)   Alias: desi
.....Title: "Why Economic Reform is a Joke"
.....Date: 4/2/2002  10:15 AM
.....Original Date: 4/1/2002 10:30 PM
.....
.....Just because it is!
```
You should print the following for a followup:
<name> " (" <alias> ") follows up to " <name> " (" <alias> ") " [ "SUCCESSFULLY" | "FAILS" ]

A follow up fails if there is no article at that date and time. It also fails if the followup time is BEFORE the time of the article it follows up.

GOLD, SILVER, BRONZE

Each member will have one of three kinds of memberships.

GOLD Unlimited postings
SILVER Can post only 2 posts a day, and up to 2 followups. (so 4 posts total)
BRONZE Can post once a day, either a regular post or a follow.

The primary input will only have members with GOLD membership to make your life easier.

Followups

You can followup to any journal entry or MP3. The followup will always be another journal entry. Followups can also be followed up. For example, if member A posts an article, then any member can post a followup to A (say, member B). Suppose member C follows up to A. Then, the output looks like:
AAAAAA AAAAAA .....BBBBBB .....BBBBBB .....CCCCCC .....CCCCCC
assuming that B's article has a date that occurs before C's article.

Assumptions

The commands are not guaranteed to be given in chronological order. For example, the input file may post a journal entry on October 2, 2000, then a journal entry on May 10, 2000.

Secondaries

Likely tests.

Test one followup
Test several followups to same article
Test followups of various depth
Test SILVER, BRONZE (to see if limits are observed)
Test REPLY

Initially, try to get the project working without any followups, assuming GOLD membership, and just regular friends (no good friends). You should then work on good friends and followups first, and BRONZE and SILVER later on.

Web Accessibility