LineCounter.java

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

/**
 * @author Matt Henry
 * 
 *         This program is to be run with a txt or csv file name passed in as a
 *         parameter. The file will be opened, the number of lines will be
 *         counted, the file will be closed, and a brief report about the file
 *         including number of lines contained in the file will then be printed
 *         to the console. Only files of type csv and txt will be accepted. All
 *         file new line indicators are assumed to be a carriage return followed
 *         by a line feed (DOS/Windows format).
 * 
 */
public class LineCounter {

	Scanner scanner; // for txt reading


	private String fileName;
	private String fileType;
	private int numLines;

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		// make sure argument has been provided
		if (args.length == 0) {
			System.out
			.println("Usage: LineCounter filename");
			System.exit(0);
		}

		LineCounter lineCounter = new LineCounter(args[0]);

		// validate file
		if (!lineCounter.validateFile()) {
			System.out.println("Invalid file type. Must be txt or csv file.");
			System.exit(0);
		}

		// count lines in file
		if (lineCounter.getFileType().equals("txt")) {
			lineCounter.countTxt();
		} else {
			lineCounter.countCsv();
		}

		// print report
		lineCounter.printReport();

	}

	/**
	 * @param fileName
	 * 
	 *            Constructor
	 * 
	 */
	LineCounter(String fileName) {
		this.fileName = fileName;
	}

	/**
	 * @param fileName
	 * @return
	 * 
	 *         validates the file name as txt/csv and returns true if valid
	 */
	boolean validateFile() {

		if (fileName.length() < 5) {
			return false;
		}

		String fileExtension = fileName.substring(fileName.length() - 4, fileName.length());

		if (fileExtension.equals(".txt") || fileExtension.equals(".csv")) {

			fileType = fileName.substring(fileName.length() - 3, fileName.length());

			return true;
		}
		return false;
	}

	/**
	 * counts number of lines in txt file
	 */
	private void countTxt() {

		try {
			System.out.println("Opening " + fileName);
			scanner = new Scanner(new FileReader(fileName));
		} catch (FileNotFoundException e) {
			System.out.println("File not found. Please make sure file exists.");
			System.exit(0);
		}

		while (scanner.hasNextLine()) {
			scanner.nextLine();
			numLines++;
		}

		scanner.close();
	}

	/**
	 * countCsv counts number of rows contained in a csv file. csv file is assumed to be
	 * a valid csv file as specified in RFC 4180 -
	 * http://tools.ietf.org/html/rfc4180
	 * 
	 * The logic in this method will increment numLines if the new line (CR LF)
	 * combination is found not in a 'protected' section, and is not directly
	 * followed by the end of the file. A protected section is defined by being
	 * contained in quotes. As specified by RFC4180, any record in the csv
	 * containing a new line char(CR LF), comma(44), or double quote(34) must be
	 * contained in double quotes. In addition, and double quotes contained in a
	 * record must be escaped by a preceding double quote.
	 * 
	 * I've designed the logic in this method using a state machine. The states
	 * are defined as:
	 * 
	 * State 1 - Non Protected(or protected section is past). Consume all chars
	 * 			except: 
	 * 			CR - go to state 5 
	 * 			EOF - end 
	 * 			" = go to state 2 
	 * State 2 - Begin protected record. Consume all chars except:
	 * 			" - go to state 3
	 * State 3 - Saw a double quote inside of a protected section. Indicates
	 * 			protected section is now over, or this double quote will preceed
	 * 			(escape) another double quote. Consume all chars except:
	 * 			" - go to state 4 
	 * 			EOF - end 
	 * 			, - go to state 1 
	 * State 4 - Presence of a double quote directly after another double quote while in
	 * 			 a protected section. This quote has been escaped by the 
	 * 			preceeding quote. Consume all chars except:
	 *			" - go to state 3 
	 * State 5 - CR present outside of protected section. Go to stage 1 for all 
	 * 			chars except:
	 * 			 LF - go to state 6
	 * State 6 - New line indicator (CR LF) present. Increment line count and go to
	 * 			 state 1 for all chars except:
	 * 			" - increment line count, go to state 2 
	 * 			EOF - end
	 */
	private void countCsv() {

		BufferedReader br = null;
		int chr;
		int state = 0;
		boolean running = false;

		try {
			br = new BufferedReader(new FileReader(fileName));
			running = true;
		} catch (FileNotFoundException e) {
			System.out.println("File not found. Please make sure file exists.");
			System.exit(0);
		}

		while (running) {

			try {

				// read each character
				chr = br.read();
				
				if (state == 0) { // beginning state
					switch (chr) {
					case -1: { // if file is empty it goes to state 7, and no
						// lines are counted.
						running = false;
						break;
					}
					case 34: { // if quote is first char, goes to state 2,
						// account for first line
						state = 2;
						numLines++;
						break;
					}
					default: { // else consume chars, account for first line
						state = 1;
						numLines++;
						break;
					}
					}

				} else if (state == 1) {

					switch (chr) {

					case 13: { // CR
						state = 5;
						break;
					}
					case -1: { // EOF
						running = false;
						break;
					}
					case 34: { // "
						state = 2;
						break;
					}
					default: {
						state = 1;
						break;
					}
					}

				} else if (state == 2) {

					switch (chr) {

					case 34: { // "
						state = 3;
						break;
					}
					default: { // consume
						state = 2;
						break;
					}
					}

				} else if (state == 3) {

					switch (chr) {

					case -1: { // EOF
						running = false;
						break;
					}
					case 34: { // "
						state = 4;
						break;
					}
					case 13: { // CR
						state = 5;
						break;
					}
					case 44: { // ,
						state = 1;
						break;
					}
					}

				} else if (state == 4) {

					switch (chr) {

					case 34: { // "
						state = 3;
						break;
					}
					default: {
						state = 4;
						break;
					}
					}

				} else if (state == 5) {

					switch (chr) {

					case 10: { // LF
						state = 6;
						break;
					}
					default: {
						state = 1;
						break;
					}
					}

				} else if (state == 6) {

					switch (chr) {

					case -1: { // EOF
						running = false;
						break;
					}
					case 34: { // "
						state = 2;
						numLines++;
						break;
					}
					default: {
						state = 1;
						numLines++;
						break;
					}
					}
				} 

			} catch (IOException e) {
				System.out.println("Unable to read file.");
			}
		}

		try {
			br.close();
		} catch (IOException e) {
			System.out.println("Unable to close file.");
		}
	}

	/**
	 * print brief summary
	 */
	private void printReport() {
		System.out.println("File name: " + fileName + ".");
		System.out.println("Total lines: " + numLines + ".");

	}

	public String getFileType() {
		return fileType;
	}

}