My Proposed Algorithm

Please note, I created this algorithm before the class discussion. It is highly likely that the algorithm produced in class will be different.

Main:
- ```
Open transactionFile 
Read an order file name
while not at the end of transactionFile
    Process the order
    Read a new order file name
Close the orderfile
```
- What variables will be needed in the main
  - A ifstream for the transaction file
  - A string for the file name.
- Any constants for the main?
  - The transaction file is a constant.
Does Read an order file name need a function?
- It is low level code, so perhaps, the guide section on function cohesion says not to mix low and high level concepts.
- I want to demonstrate passing a file handle
- So I will make functions to open, read and close the orderfile.
- In this class, more functions are better.
- This philosophy yields three more functions.
  - OpenTransactionFile
  - ReadOrderFileName
  - CloseTransactionFile

The Design Document template for the main

We have the algorithm.

What can we use for a narrative?

The main program will open and process the transaction file, one order at a time until all orders have been processed.

Let's take care of the easy routines next.
OpenTransactionFile
- This is really just an open statement.
- Or is it.
- What should we do if we fail to open the file?
  - Is this covered in the assignment statement?
  - We should ask about this.
- What is the input/output to this function?
  - I will need to return an open file. How do I do this?
  - Since it is a variable thing, we need to pass by reference.
- A narrative is probably sufficient here.
- - Function: OpenTransactionFile
  - Narrative: This function will open the transaction file. There is no error reported if the file is not opened.
  - Input: none
  - Output: the file stream, either open or in an error state.
The other two file related functions are similar.
ProcessOrder
- We will be given the order name as input
- There really is not return value (output) from this file.
- What do we need to do
- ```
Open the order file
if successful
    Process  an order
    close the file
else
    print error message
```
- is this good?
  - It might be too simple.
  - But it does remove one degree of complexity from the next level down
    - Dealing with the existence of the order file. If the code gets there, then the order file exists.
- What is the input?
  - The file name
- What is the output?
  - Nothing
- Documentation:
  - Function: ProcessOrder
  - Narrative: This function, given the name of an order file, will open the file and process it if possible. If not it will report an error.
  - Input: The input file name, a string
  - Output: none.
ProcessAnOrder
- This will take a open file stream.
- No return value
- ```
Open output file
Process header
Get a line item
While there are line items
   Process line item
   Get a line item
Print the order totals
Close the files
```
- Documentation:
  - Function: ProcessAnOrder
  - Narrative: This function, the stream for an open order file, will perform the actual processing of the order.
  - Input: an open file stream
  - Output: none.

ProcessHeader

Will need a open input file and output file stream.

Print "Packing Slip"
Print Address
Print Column Headers

I think the following might be helpful here

const string ORDER_TITLE = "PACKING SLIP";
const int TOTAL_WIDTH = 80;
...
cout << setw(TOTAL_WIDTH/2-ORDER_TITLE.lenght()/2) << ORDER_TITLE << endl ;

Printing the title and column headers are mechanical, use setw
Printing the address should be looked at

PrintAddress

Will need a open input file and output file stream.

Read the first name from the input file
Read the last name from the input file
Print firstName + " " + lastname right justified to output file
Read first address line
Print first address line to output file.
Read second address line
If the second address line is not a blank, print the second address line.
PrintStateCityZip

This will mostly be handled with setw.
CityStateZip
- is complex enough that I will write a routine to handle it.
- Besides, I think the file format is broken and I might change this in the future.

ProcessLineItem

It will take the two files again.

Read in item number, quantity, weight and size.
Calculate total weight
Add to total items, grand total weight and the proper volume count
Print the line

When I typed this up, I realized that I was missing something from ProcessAnOrder

Declare and initialize the different totals.

        (Process An Item, new algorithm)
Initialize totals
Open output file
Process header
Get a line item
While there are line items
   Process line item
   Get a line item
Print the order totals
Close the files

I will also need to pass these totals into this function.
However, I think this is a leaf routine.

As I was cleaning up, I notiecd that I did the work o f GetLineItm in ProcessLineItem.
- Should I just ditch GetLineItem?
- Looking at the algorithm for ProcessAnOrder, GetLineItem is called from multiple locations.
  - This follows the pattern for reading from a file without the end of file bug.
- It is responsible for reading the items.
- But also it will set off the end of file condition that will end the main loop.
- I think I want to keep it.
- ```
        ProcessLineItem (revised)
Calculate total weight
Add to total items, grand total weight and the proper volume count
Print the line 
```