TArray0.java

/*
    TArray0.java
    David Klick
    CIS 260
    3/23/09

This program demonstrates a number of Java features including
    keyboard input, string tokenization, the use of multiple classes,
    customized exceptions, exception handling, and a Hashtable. A
    simple parser controls access to an unordered array, which the
    user can manipulate interactively.
*/

import java.util.*;
import java.io.*;

public class TArray0 {
    private static final int DEFAULT_ARRAY_LENGTH = 10;
    private static BufferedReader in = new BufferedReader(
        new InputStreamReader(System.in));
    public enum Command { QUIT, PRINT, STATUS, HELP, ADD,
                          INSERT, DELETE_AT, DELETE, FIND
                        }

private static Hashtable<String, Command> initCommandTable() {
        Hashtable<String, Command> hash = new Hashtable<String, Command>();
        hash.put("QUIT", Command.QUIT);
        hash.put("Q", Command.QUIT);
        hash.put("EXIT", Command.QUIT);
        hash.put("X", Command.QUIT);
        hash.put("PRINT", Command.PRINT);
        hash.put("P", Command.PRINT);
        hash.put("STATUS", Command.STATUS);
        hash.put("STAT", Command.STATUS);
        hash.put("S", Command.STATUS);
        hash.put("HELP", Command.HELP);
        hash.put("H", Command.HELP);
        hash.put("FIND", Command.FIND);
        hash.put("F", Command.FIND);
        hash.put("?", Command.FIND);
        hash.put("ADD", Command.ADD);
        hash.put("A", Command.ADD);
        hash.put("+", Command.ADD);
        hash.put("DELETE", Command.DELETE);
        hash.put("DEL", Command.DELETE);
        hash.put("D", Command.DELETE);
        hash.put("-", Command.DELETE);
        hash.put("DELETE_AT", Command.DELETE_AT);
        hash.put("DELETEAT", Command.DELETE_AT);
        hash.put("INSERT_AT", Command.INSERT);
        hash.put("INSERTAT", Command.INSERT);
        hash.put("INS", Command.INSERT);
        hash.put("I", Command.INSERT);
        return hash;
    }

private static void error(String msg) {
        System.out.println(msg);
    }

private static boolean isInteger(String s) {
        return s.matches("[+-]?[0-9]+");
    }

private static void println(String msg) {
        System.out.println(msg);
    }

public static void main(String[] args) throws IOException {
        boolean done = false;
        int arrayLength = DEFAULT_ARRAY_LENGTH;

// process command line parameters (array length)
        if (args.length == 1) {
            try {
                arrayLength = Integer.parseInt(args[0]);
                if ((arrayLength > 20) || (arrayLength < 5)) {
                    println("Illegal array length specified");
                    arrayLength = DEFAULT_ARRAY_LENGTH;
                }
            } catch (NumberFormatException e) {
                error("Unrecognized command line argument");
                System.exit(0);
            }
        } else if (args.length > 1) {
            error("Only one command line parameter allowed. "
                  + args.length + " found.");
            System.exit(0);
        } else {
            error("No command line parameters found. Using default"
                  + " array size of " + DEFAULT_ARRAY_LENGTH + ".");
        }

// create array to be used for application
        UnorderedArray a = new UnorderedArray(arrayLength);

// intialize command lookup table
        Hashtable<String, Command> commands = initCommandTable();

// process commands
        displayHelp();
        System.out.println("\nProgram ready for processing");
        while (!done) {
            int position, value;
            String[] cmd = getCommand();
            int cmdLength = cmd.length;
            Command command = commands.get(cmd[0].toUpperCase());
            if (command == null) error("Unrecognized command");
            else {
                switch (command) {
                case QUIT:
                    if (cmdLength > 1) error("QUIT command takes no arguments");
                    else done = true;
                    break;
                case PRINT:
                    if (cmdLength > 1) error("PRINT command takes no arguments");
                    else a.print();
                    break;
                case STATUS:
                    if (cmdLength > 1) error("STATUS command takes no arguments");
                    else displayStatus(a);
                    break;
                case HELP:
                    if (cmdLength > 1) error("HELP command takes no arguments");
                    else displayHelp();
                    break;
                case FIND:
                    if (cmdLength != 2) error("FIND command takes one argument");
                    else {
                        if (!isInteger(cmd[1])) error("FIND command argument must be an integer");
                        else {
                            position = a.findElement(Integer.parseInt(cmd[1]));
                            if (position == -1) println(cmd[1] + " not found in array");
                            else println(cmd[1] + " found at position " + position);
                        }
                    }
                    break;
                case ADD:
                    if (cmdLength != 2) error("ADD command takes one argument");
                    else if (!isInteger(cmd[1])) error("ADD command argument must be an integer");
                    else {
                        try {
                            value = Integer.parseInt(cmd[1]);
                            a.addElement(value);
                            println("Element with value " + value + " added");
                        } catch (MyArrayException e) {
                            error(e.getMessage());
                        }
                    }
                    break;
                case INSERT:
                    if (cmdLength != 3) error("INSERT command takes two arguments");
                    else {
                        if (!isInteger(cmd[1])) {
                            error("INSERT command position argument must be an integer");
                            continue;
                        }
                        if (!isInteger(cmd[2])) {
                            error("INSERT command value argument must be an integer");
                            continue;
                        }
                        position = Integer.parseInt(cmd[1]);
                        value = Integer.parseInt(cmd[2]);
                        try {
                            a.insertElement(position, value);
                            println("Element with value " + value + " inserted at " + position);
                        } catch (MyArrayException e) {
                            error(e.getMessage());
                        }
                    }
                    break;
                case DELETE:
                    if (cmdLength != 2) error("DELETE command takes one argument");
                    else if (!isInteger(cmd[1])) error("DELETE argument must be an integer");
                    else {
                        value = Integer.parseInt(cmd[1]);
                        if (a.deleteElement(value)) println("Element with value " + value + " deleted");
                        else println("Element with value " + value + " not found");
                    }
                    break;
                case DELETE_AT:
                    if (cmdLength != 2) error("DELETE_AT command takes one argument");
                    else if (!isInteger(cmd[1])) error("DELETE_AT argument must be an integer");
                    else {
                        position = Integer.parseInt(cmd[1]);
                        try {
                            a.deleteElementAt(position);
                        } catch (MyArrayException e) {
                            System.out.println(e.getMessage());
                        }
                    }
                    break;
                default:
                    error("Unrecognized command");
                }
            }
        }
        // end of command processing loop
        println("End of processing");
    }

public static String[] getCommand() {
        String s = new String();
        System.out.print("\n> ");
        try {
            while ((s = in.readLine()).length() == 0);
        } catch (IOException e) {
            System.out.println("I/O Exception");
        }
        s = s.toUpperCase();

StringTokenizer p = new StringTokenizer(s);
        String[] cmds = new String[p.countTokens()];
        try {
            int i = 0;
            while (p.hasMoreTokens())
                cmds[i++] = p.nextToken();
        } catch (NoSuchElementException e) {
            System.out.println(e);
        }
        if (cmds.length > 0) {
            // This handles the special case where the first character
            // is a plus (insert) or minus (delete) and is followed by
            // a number without any delimiter in between. This code
            // breaks the single "word" into two separate "words"
            char c = cmds[0].charAt(0);
            if ((cmds[0].length() > 1) && ((c == '+') || (c == '-'))) {
                String[] newCmds = new String[cmds.length + 1];
                for (int i=1; i<cmds.length; i++) newCmds[i+1] = cmds[i];
                newCmds[0] = cmds[0].substring(0,1);
                newCmds[1] = cmds[0].substring(1);
                cmds = newCmds;
            }
        }
        return cmds;
    }

public static void displayHelp() {
        System.out.println("\nThis program lets you manipulate a small int array using");
        System.out.println("keyboard commands. Commands may be entered in either");
        System.out.println("upper or lower case. Put spaces between commands and values");
        System.out.println("if values are involved. All values must be integers.");
        System.out.println("The available commands are:\n");
        System.out.println("exit, x, quit, q: quit the program");
        System.out.println("print, p: display the contents of the array");
        System.out.println("status, stat, s: display stats about the array");
        System.out.println("help, h: display program help");
        System.out.println("find, f, ?: a value must follow the command; finds");
        System.out.println("      an element with that value");
        System.out.println("add, a, +: a value must follow the command; adds the");
        System.out.println("      value as the new last element if room is available");
        System.out.println("insert_at, insertat, ins, i: an index and a value must follow");
        System.out.println("      the command; inserts the value at the given index");
        System.out.println("delete, del, d, -: a value must follow the command; deletes");
        System.out.println("      element with that value");
        System.out.println("delete_at, deleteat: an index must follow the command; deletes");
        System.out.println("      the element at that position in the array");
    }

public static void displayStatus(UnorderedArray a) {
        System.out.println("Status: size = " + a.size + ", number of elements = " + a.numElements);
    }
}

class UnorderedArray {
    int[] arr;
    int numElements = 0;
    int size = 0;

public UnorderedArray() {
        this(10);
    }

public UnorderedArray(int n) {
        arr = new int[n];
        numElements = 0;
        size = n;
    }

public void clear() {
        numElements = 0;
    }

public int getElementAt(int pos) throws MyArrayException {
        if (pos < 0) throw new MyArrayException("Index out of bounds");
        else if (numElements <= pos) throw new MyArrayException("No element at position specified");
        return arr[pos];
    }

public void deleteElementAt(int pos) throws MyArrayException {
        if (pos < 0) throw new MyArrayException("Index out of bounds");
        else if (numElements <= pos) throw new MyArrayException("No element at position specified");
        for (int i=pos; i<numElements-1; i++) arr[pos] = arr[pos+1];
        numElements--;
    }

public boolean deleteElement(int val) {
        boolean found = false;
        for (int i=0; i<numElements; i++) {
            if (arr[i] == val) {
                arr[i] = arr[--numElements];
                found = true;
                break;
            }
        }
        return found;
    }

public void addElement(int val) throws MyArrayException {
        if (numElements < size) arr[numElements++] = val;
        else throw new MyArrayException("Array full");
    }

public void insertElement(int pos, int val) throws MyArrayException {
        if (pos < 0 || pos >= size) throw new MyArrayException("Index out of bounds");
        if (pos > numElements) throw new MyArrayException("Index not in populated part of array");
        if (numElements < size) {
            for (int i=size-1; i>pos; i--) arr[i] = arr[i-1];
            arr[pos] = val;
            numElements++;
        } else throw new MyArrayException("Array full");
    }

public int findElement(int val) {
        for (int i=0; i<numElements; i++)
            if (arr[i] == val) return i;
        return -1;
    }

public void print() {
        for (int i=0; i<numElements; i++)
            System.out.print(Integer.toString(arr[i]) + "  ");
        System.out.println();
    }
}

class MyArrayException extends Exception {
    public MyArrayException() {}
    public MyArrayException(String msg) {
        super(msg);
    }
}