CSE 143 Spring 2001 Homework 3 Due: Electronic submission by 10 pm, Wednesday April 25.  Paper receipt and written report due in quiz section on Thursday April 26.

Overview

For this assignment, write a program that allows users to browse for CD information. The users can search for CDs by title or by performer.

As with all assignments, please read the instructions all the way through before beginning.  Read them once again before you turn in your assignment, to be sure you've left nothing out.

Concepts

The goal of this assignment is to gain experience with the following the following concepts:

• Use of dynamic data structures in classes (allocation, automatic expansion, deletion)
• Destructors
• Copy constructors
• Assignment operators

Program Specification

This program maintains a database of information about CD's and allows the user to manipulate and examine that information.  For each CD, the program maintains the following information:

• CD serial number (a string). Each CD has a unique serial number - no two CDs share the same number.
• CD title
• Performer(s)
• Price in $
• Review

The price is a decimal number (15.95, for example); all other data is represented by strings.

When the program starts, the database is initially empty.  The program should repeatedly present the user with a menu of possible commands, then accept a command and carry it out.  This continues until the user stops the program by entering a quit command.

The available commands are indicated by a letter, which can be either upper or lower case.  The available commands are:

• r or R: Read a file
• t or T:  Search CDs by title
• p or P: Search CDs by performer
• q or Q: Quit

After the user enters a command letter, the command should be processed as described in the following sections.  Once the command is processed, if the command was anything other than quit, the program should request a new command and continue.

r or R: Read a file

When the user selects this option, the program should prompt for a file name and try to open that file. If it fails, it should report an error and return to the main menu.

Upon successfully opening the file, the program should read CD information from it and merge this information into the database (more about that below). The file is composed of blocks of 5 lines each, in the following order:

CD#
Title
Performer(s)
Price
Review

There might be any number of such blocks, including none, and there is no limit on how many blocks the file may contain. The end of the input is marked by an empty line when the next CD# would normally be, and the program should stop reading data at that point. You should assume that the input is clean. Specifically, the following fields will never be empty: CD#, Title, and Price (Performer and Review might be empty), and no field will span multiple lines. An example is given below.

All CD info from the file should be “merged” into the existing database. This means:

• CDs which do not already appear in the database should be added to it.
• CDs already in the database should be updated to reflect the new information from the file.  The new information completely replaces the old information for that CD.

A CD is said to be in the database if the database already contains an entry with the same CD#. Different CDs may have the same title, same performer, same price, or same review, but the CD# is guaranteed to be unique.

-------------- START OF EXAMPLE FILE ------------------
9 25789-2
Negotiations and Love Songs
Paul Simon
12.99
This is a great CD. You really should buy it right away, and I mean now!
CDP 0777 7 89282 2 5
The Best of Chick Corea
Chick Corea
10.99
Good one.

--------------- END OF EXAMPLE FILE -------------------

t or T: Search by title

When the user selects this option, the program should ask for a word to search for in the song titles. It should then display a list of all CDs whose titles contain that word, in the following format:

1. Paul Simon: Negotiations and Love Songs [$12.99]
2. Chick Corea: The Best Songs of Chick Corea [$10.99]

The program should then ask the user for a number, which selects an item in the list (that is, “2” would indicate the Chick Corea CD). If the user enters “0” the program should return to the main menu. Otherwise, it should display the complete information for the selected CD, in whatever format you wish (but try to make it as usable as possible).

After displaying the CD information, the program should redisplay the same list found in the title search, and prompt the user for another number, continuing until the user enters 0 to return to the main menu.

p or P: Search by performer

This option is very similar to the previous (search by title), except that the search is done on performers: any CD whose performer contains the specified search word should be displayed. Everything else should work exactly the same as in a title search.

q or Q: Quit

Exit the program. Make sure that you clean up all dynamically allocated memory before the program actually terminates. 

Implementation Requirements

The main technical goal of this assignment is to learn to use classes that have dynamically allocated data structures.  Specifically, the database of CD information should automatically grow as needed.  The database should be implemented as a class that contains a dynamic array of CD records (CD records being instances of another class). The database class should have at least the following functionality:

• A default constructor that creates a correctly initialized empty database.
• A destructor that cleans up all dynamic memory that was allocated by the database object.
• An assignment operator (operator=) that correctly copies the contents of the assigned database.
• A copy constructor.

You will need to add additional operations to this class, of course, to implement the rest of the program.

Depending on how you write the client program, you might wind up not actually using the copy constructor or assignment operator in the client code.  However, a well-designed C++ class should contain these member functions.  You should include them in your class, and, if necessary, do some extra testing to verify that they work.

As usual, watch out for style and modularity issues.  Also, continue to avoid using C strings when C++ strings will do the job, C standard I/O (e.g. printf), etc.

Implementation Hints

As is usually the case, you will find it very helpful to do some designing before you start writing detailed code.  What is the high-level structure of the code?  What sort of data structure operations are needed to process the various commands?

A few specific suggestions and reminders:

• Exploit the class that you design to hold the CD database.  Besides having one instance of this class to hold the complete database, you may find it very useful to create other instances to hold the partial lists accumulated by the various searches.
• You need to pick some default initial capacity for the CD database class.  If you start with an artificially small size like 3 or 4, it will be easier to ensure that your tests exercise the code that dynamically expands the array. 
• Look at the various getline() functions in the I/O libraries - they may be useful for reading the input file.  The getline() member function of istream only works on C-strings (arrays), but there is a free-standing function getline(stream,cppstring) that reads a line from the specified input stream into a C++ string cppstring. (Substitute appropriate stream and string variable names for your code, of course.)
• Remember that CD serial numbers are strings, and not necessarily numeric.
• Remember that some fields in the input file may be empty without indicating the end of the file (e.g., reviews).
• Try to write your code in an extensible way, so that future modifications wouldn’t be too difficult. Examples for plausible future additions are:
• Adding/changing fields in the CD record (e.g. playing time).
• Adding/changing search criteria (e.g. review keywords).
• Enabling the user to enter new CDs to the database from the console.

Testing

Think about interesting test cases for your program. A few suggestions (by no means a complete list!):

• Performing queries on an empty database.
• Reading empty files (with a single blank line).
• Reading files that change some or all existing records.
• Performing queries that return none of the records, or all of them.
• Whatever other borderline cases that might be a problem for the program.

Report

You know the drill by now: planning, implementation, testing, what you’ve learned.

Note: When describing the implementation, please don’t repeat stuff that is already documented in the code. Instead, describe what was problematic or interesting in your implementation, and how you handled these cases.

Sample Program

Also, as usual, there is no sample program for this assignment.  In cases where the specification is not clear, you may need to make some reasonable assumptions.  Feel free to discuss issues about the specifications on the course newsgroup, in sections, with your colleagues, etc.

Electronic Submission

When you've finished your program, turn in the source program (.cpp and .h files only) using this turnin form . Print out the receipt that appears, staple it and your written report together, and hand it in during quiz section.