This problem is an exercise in operator overloading, and further development of template classes. Begin your work early!

Specifications:

• Readings: C++ text Chapters 11-12
• Compilation: g++ -std=c++98 -ansi -pedantic -Wall -Wextra -O
• Collaboration: This is a pairs programming assignment. Both partners will receive the same grade. Only one of you should submit the solution on webCT. However, you must individually complete partner evaluations that you will each submit on webCT (as a separate plain text file). You may choose your own partner, but it can not be the same person you worked with in the previous partner assignment. It also cannot be anyone you are currently working with in other classes. This partner will be one of your group members for the final project. Each pair must email the partners' names and email addresses to Joanne by 6pm on Friday, 4/9. You can use lab to find a partner if needed.
• Submission: You must again use tar/gzip to collect all the program files you are submitting (all *.h, *.cpp and your makefile) into one compressed file. Make sure that your makefile is updated for the C++ compiler. Submit your tarball electronically on webCT. Submit printouts of your *.cpp files only (not *.h, *.txt or makefile) in class.
• Grading: 65 points total:
  • [35] ContextIndex template class
  • [15] Card class
  • [10] input text file for cards
  • [5] code reuse, style, efficiency, submission
  -5 points if there are any warnings using the required compilation options. 0 points if the files don't all compile together (ie, any file has errors, no a.out created). Continue to use good incremental coding development and ruthless testing.

The Problem:

A context index is defined as an ordered index of significant items from a collection, each displayed within a subset called their context. Each context must extend far enough to contain a certain number of significant items on either side of the indexed item, if possible. Typically, the entries in the index are aligned so that the significant items each entry is built around are in the same column, and somehow highlighted (with <> in the examples below).

For example, given the following collection of integers, let's decide that "significant" means >=100. If we require two significant items in the left and right contexts of each index entry, the resulting index is as follows.

Integer collection:  23 405 203 39 4059 20 39 581 3049 293 4 581 222 3940

Context index:
           23 405 <203> 39 4059 20 39 581
        293 4 581 <222> 3940
         581 3049 <293> 4 581 222
               23 <405> 203 39 4059
203 39 4059 20 39 <581> 3049 293
       3049 293 4 <581> 222 3940
   4059 20 39 581 <3049> 293 4 581
          581 222 <3940>
       405 203 39 <4059> 20 39 581 3049

Note that 405, 203, 222, and 3940 appear as entries even though they do not have 2 significant entries in a context to the left and right. Notice that 581 appears twice, each with a different context, ordered with the first context before the second.

As another example, suppose we define a word to be "significant" if it has at least 4 characters. We can define our own string class called Word that would redefine the comparison operators to mean that a string is >= "aaaa" if it has at least 4 characters and follows "aaaa" alphabetically, regardless of letter case (upper or lower). In this Word class, a shorter string is always less than a longer string, regardless of alphabetical ordering. For example, "zZ" < "Aaa". We can create a context index for text using this type of comparison, similar to the context index for integers above. Here is an example, for 3 significant items on either side of the entry, using * to highlight the central entry item:

Text to process: the quick RED fox jumped OVer the lazY brown dog

Resulting context index:

quick red fox jumped over the *lazy* brown dog
     the quick red fox jumped *over* the lazy brown dog
         jumped over the lazy *brown* dog
                          the *quick* red fox jumped over the lazy
            the quick red fox *jumped* over the lazy brown

The purpose of this assignment is twofold. The primary purpose is to design and implement a context index template class for creating context index objects that could be used with various data types, assuming that necessary operators have been overloaded. Each object should have only the necessary data in it, carefully encapsulated and protected [6 pts]. Your context index class must support this public interface:

• [4] Construct a context index object by passing it a minimum constant value which will be used to decide which items in the file are significant. You should not be able to create a context index without this, since it will establish the type of the template. Use a second parameter with default value of 2 to indicate the number of significant objects required to the right and left in each index entry.
• [4] Overload the input operator (stream extraction) so that it can be used to initialize the index by reading an input stream object. The data read will form the original collection of items for the context index. Assume that items of your base type appear sequentially in the stream with any type of whitespace separators (similar to the examples above). You can assume (and should note with a comment on your function) that this function requires the input operator to be overloaded for any item type used in an index.
• [4] Return the original collection as a doubly linked list of items. In this case, you must use the doubly linked list class that you created for assignment 6. You are forbidden to use the STL list class anywhere in this assignment. You and your partner should review, test and choose the best implementation of your two solutions. (Ie, do not rely on our grading to determine which to use.) Add to your linked list class as necessary in order to make it work with our driver program for this assignment. Make sure you submit all necessary linked list files!
• [12] Build the full, ordered context index. (Hint: make an ordered Set of contexts - this would require writing a separate context class. If you do this, make sure you submit all the necessary Set and Context related files!)
• [5] Overload the output operator (stream insertion) so that it can be used to write the fully ordered context index to any output stream.

The second purpose of this assignment is to create a new data type which can be used as a base type for creating a context index of playing cards. This Card class must define comparisons based first on face values, breaking ties with suits. The suit ordering from least to greatest is Diamonds, Clubs, Hearts, Spades (note this is not alphabetical). The face values are compared based on their numerical equivalents. If a collection of cards were sorted based on this comparison, then all the 2s would appear first, in the suit order given above, and so on, with the Aces appearing last (face value 14).

Minimally, you must overload this set of operators for the Card class so that it can be used as the base type for a context index: {<<, >>, =, ==, <, <=}. You may build upon the Card(S) structs that are posted in the code directory, or create your own class from scratch. It is up to you to decide how to represent cards for input and output purposes (see creating an input test file below). It can range from very terse (for example, 7D) to very verbose (7 of Diamonds).

Create a plain text file with a sequence of cards that can be used to test your context index class above. Make the file to correspond to how you overload the input operator for your Card class.

Test your classes with the following simple driver program: p7.cpp. You may add to this for more robust testing.