Program 4
Due: Thursday, April 23, 2009

Write a program that maintains the data about an airline's routes. It
contains information about airports and connections between airports.
Each airport has the following data:
  code: a three letter code that uniquely identifies the airport
  name: a string that could contain blanks
  capacity: a positive integer giving the maximum number of flights that the
            airport could handle in one day

Each connection is specified by the airport that it departs from and the airport it
arrives at, and it has the following data:
  distance: a positive real number giving the distance between the two airports

This data can be updated with the following commands.  Each command has a two
letter abbreviation (upper or lower case), which is indicated in
parentheses after its name.  Some commands also have arguments shown in angle
brackets (<>).

1. Add Airport (AA) <code>

   If there is no airport with that <code>, then a new airport with that code is added,
   and the program prompts the user for the name and capacity of the new airport. 
   
2. Delete Airport (DA)  <code>
   
   The program finds the airport with that code, and displays that airport's data, followed
   by a message asking if the user wants to delete that airport. The user responds
   yes or no.  If the response was yes, then that airport is removed, and all connections
   going to or from that airport are removed.

3. Add Connection (AC) <code1> <code2> <distance>

   If <code1> and <code2> are valid airport codes with no connection from the first to
   the second, and <distance> is a valid distance, then a connection with that distance
   is added between <code1> and <code2>. Note that existence of a connection from <code1>
   to <code2> does not imply there is a connection in the opposite direction, or even if
   there is, that the distances must be the same.

4. Delete Connection (DC) <code1> <code2>

   If <code1> and <code2> are valid airport codes, the program displays the data for that
   connection (codes and airport names for the two airports, and the distance between them),
   and asks if the user wants to delete that connection.  The user responds yes or no.
   If the response was yes, then that connection is removed.

5. List Airports (LA)

   Displays all airports and their associated data, and for each airport, it shows all
   connections departing from that airport (destination and distance).

6. Find Path (FP) <code1> <code2>

   Finds the shortest path from <code1> to <code2> (if it exists). Displays the path
   by listing each airport code in the path from <code1> to <code2>, and the total
   distance.

7. Quit (Q)

   The program ends.

Here's an example (user responses are shown in red):

Please enter a command:  aa  ord
Airport's name = Orlando
Capacity =   350
Please enter a command:  aa  lax
Airport's name = Los Angeles
Capacity =   700
Please enter a command:  aa  lag
Airport's name = La Guardia
Capacity =   590
Please enter a command:  ac lax lag 3000.8
Please enter a command:  ac lag     ord 2100.2
Please enter a command:  ac lax ord 3100.45
Please enter a command:  fp lax ord
The shortest path from lax to ord is:
  lax ord
  Total distance = 3100.45
Please enter a command:  dc lax ord
Departure:   lax Los Angeles
Destination: ord Orlando
Distance:    3100.45 miles
Do you wish to delete this connection? yes
Please enter a command:  fp lax ord
The shortest path from lax to ord is:
  lax lag ord
  Total distance = 5101.0 miles
Please enter a command:q

Use the command and data prompts as shown above. You don't have to use the same formats for the outputs of commands like fp; in fact, you should be able to do better.

template <class Key, class Elem, class Weight> class Graph {

public:
  virtual bool addVertex(const Key&, const Elem&) = 0;

  virtual bool findVertex(const Key&, Elem&) = 0;

  virtual bool delVertex(const Key&) = 0;

  virtual bool addEdge(const Key&, const Key&, const Weight&) = 0;

  virtual bool isEdge(const Key&, const Key&, Elem&, Elem&, Weight&) = 0;

  virtual bool delEdge(const Key&, const Key&) = 0;
}

The template should work for directed graphs with vertices of type Elem and keys of type Key, and edges with weights of type Weight.

• The function addVertex adds a new vertex to the graph and returns true, if there is no vertex with key given by the parameter. Otherwise false is returned.
• The function findVertex searches the graph for a vertex whose key is given by its first parameter. If it succeeds, then it sets the second parameter to the value of that vertex and returns true. Otherwise it returns false.
• The function delVertex searches the graph for a vertex whose key is given by the parameter. If it succeeds, then it removes that vertex and all edges going to or from it, and returns true. Otherwise it returns false.
• The function addEdge adds an edge from the vertex whose key is the first parameter to the vertex whose key is the second parameter, with weight given by the third parameter. There must not already be an edge from the first vertex to the second. The function returns true if it is successful; otherwise it returns false.
• The function isEdge tests whether there is an edge from the vertex whose key is the first parameter to the vertex whose key is the second parameter. If there is such an edge, then it sets the third and fourth parameters to the values of these vertices and the fifth parameter to the weight of the edge, and returns true. Otherwise it returns false.
• The function delEdge removes the edge from the vertex whose key is the first parameter to the vertex whose key is the second parameter and returns true, if the edge exists. Otherwise it returns false.

1. Hardcopy of all your source code.
2. Hardcopy of your program's execution. It should show all prompts and output from the program, including error messages, and all commands and data entered by the user.
3. Submit your source code files and an executable file named p3 by copying (or ftping) them to a specially designated directory in AFS. Each person in the class has a subdirectory which has the same name as your login name in /afs/cu/class/cs344jl

   Within this individual directory, create a subdirectory named p4. Copy all your source files and the executable file p4 into your p4 directory, including header files, but no object or executable files. So, for example, if your login name was smithjd then your source files should be copied to /afs/cu/class/cs344jl/smithjd/p4. These directories have permissions set so that no one other than yourself and Prof. Lynch can read the files. You may, of course, use whatever operating system and compiler you wish to develop your code, but the version you turn in, both hardcopy and the files submitted to AFS, must compile with g++ and run under polaris.

• Correct execution. The program must follow all the specifications above. The hardcopy of your program's execution should clearly demonstrate that it does.
• Correct implementation. The program must follow all the design requirements above, in particular the implementation and use of the Graph template.
• Error checking. You have to figure out what kinds of errors your program should check for, and how it should handle them. The hardcopy of your execution should include examples of these error handling capabilities.
• Correct implementation of the shortest path algorithm.
• Readability of the code: commented and well-structured, so that it is clear what the algorithms and data structures are doing. Use an accepted C++ style. The style of the text is fine, or you can use whatever style you learned in previous courses. Whatever you do, be consistent.
• Appearance of the output. In particular, the output of the LA and FP commands should be neat and easy to read.
• Timely submission of your program. All hardcopy must be turned in on the due date. Late programs will not be accepted. Printouts submitted electronically will be ignored. You can turn it in to me until 3:00PM on the due date.