argumentparser.java

来自「一个java 代码生成器」· Java 代码 · 共 257 行

/**
 * Copyright (c) 2002, Siddhartha P. Chandurkar [e-mail]
 * All rights reserved.
 * Licensed under the Academic Free License version 1.1
 * See the file LICENSE.TXT for details.
 * LICENSE.txt is located in the directory  <install-directory>\Jenerator
 * of your Jenertaor Installation.
 *
 */

package com.jenerator.util;

//<Imports>

import org.apache.log4j.Logger;

//</Imports>

/**
 * ArgumentParser
 * This class is an utility class which is responsible for parsing
 * the command line arguments and validating them. If the arguments are
 * not valid then it prints the appropriate message.
 * @author Siddhartha P. Chandurkar
 * @version 0.9.0
 */
public class ArgumentParser {


    //ATTRIBUTES
    //flag denoting that the Jenerator descriptor has to be generated
    private boolean DESC = false;
    //flag denoting that the remote interfaces for Session and Enitit beans have to be generated
    private boolean REMOTE = false;
    //flag denoting that the home interfaces for Session and Entity beans have to be generated
    private boolean HOME = false;
    //flag denoting that the bean classes for Session, Entity and Message driven beans have to be generated
    private boolean BEAN = false;
    //flag denoting that the Local interfaces for entity bean have to be generated
    private boolean LOCAL = false;
    //flag denoting that the deployment descriptor for the EJB's i.e. ejb-jar.xml have to be generated
    private boolean DD = false;
    //flag for generating the JUnit test classes
    private boolean JUNIT = false;
    //flag for generating the ant's build.xml file
    private boolean ANT = false;
    //flag for generating Patterns
    private boolean PATTERN = false;
    //flag for generating servlets
    private boolean SERVLET = false;
    //flag for generating JDO relates source and descriptor
    private boolean JDO = false;
    //flag for generating Unit Tests for classes other than EJB's
    private boolean UNIT_TESTS = false;
    //The log4j logger for this class
    private Logger log = Logger.getLogger(com.jenerator.util.ArgumentParser.class.getName());

    //METHODS
    //The accessor methords for the boolean flags
    public boolean isDesc() {
        return DESC;
    }

    public boolean isRemote() {
        return REMOTE;
    }

    public boolean isHome() {
        return HOME;
    }

    public boolean isBean() {
        return BEAN;
    }

    public boolean isLocal() {
        return LOCAL;
    }

    public boolean isDD() {
        return DD;
    }

    public boolean isJUNIT() {
        return JUNIT;
    }

    public boolean isANT() {
        return ANT;
    }

    public boolean isPATTERN() {
        return PATTERN;
    }

    public boolean isSERVLET() {
        return SERVLET;
    }

    public boolean isJDO() {
        return JDO;
    }

    public boolean isUNIT_TESTS() {
        return UNIT_TESTS;
    }

    /**
     * parseArgs
     * The method which takes the command line arguments as a parameter and parses
     * the command line and also validates them
     * @param   String  args[]  The command line arguments
     */
    public void parseArgs(String args[]) {
        if (args.length == 0) {
            printUsage();
            System.exit(1);
        }
        log.debug("Parsing arguments");

        for (int i = 0; i < args.length; i++) {
            String arg = args[i];
            if (arg.startsWith("-")) {
                if ((arg.indexOf("d") == -1) && (arg.indexOf("D") == -1) &&
                        (arg.indexOf("r") == -1) && (arg.indexOf("R") == -1) &&
                        (arg.indexOf("h") == -1) && (arg.indexOf("H") == -1) &&
                        (arg.indexOf("b") == -1) && (arg.indexOf("B") == -1) &&
                        (arg.indexOf("l") == -1) && (arg.indexOf("L") == -1) &&
                        (arg.indexOf("all") == -1) && (arg.indexOf("ALL") == -1) &&
                        (arg.indexOf("j") == -1) && (arg.indexOf("J") == -1) &&
                        (arg.indexOf("m") == -1) && (arg.indexOf("M") == -1) &&
                        (arg.indexOf("p") == -1) && (arg.indexOf("P") == -1) &&
                        (arg.indexOf("s") == -1) && (arg.indexOf("S") == -1) &&
                        (arg.indexOf("o") == -1) && (arg.indexOf("O") == -1) &&
                        (arg.indexOf("c") == -1) && (arg.indexOf("C") == -1)) {
                    printUsage();
                    System.exit(1);
                }


                if ((arg.substring(1, arg.length()).indexOf("d") != -1) || (arg.substring(1, arg.length()).indexOf("D") != -1)) {
                    if (arg.length() > 2) {
                        log.fatal("The 'd/D' option cannot be used in combination with other options");
                        System.exit(1);
                    } else {
                        log.info("generation jen-desc.xml");
                        DESC = true;
                    }
                    return;
                }//For option D/d
                if ((arg.substring(1, arg.length()).indexOf("p") != -1) || (arg.substring(1, arg.length()).indexOf("P") != -1)) {
                    if (arg.length() > 2) {
                        log.fatal("The 'p/P' option cannot be used in combination with other options");
                        System.exit(1);
                    } else {

                        log.info("generating  Patterns");
                        PATTERN = true;
                    }
                    return;
                }//For option p/P
                if ((arg.substring(1, arg.length()).indexOf("s") != -1) || (arg.substring(1, arg.length()).indexOf("S") != -1)) {
                    if (arg.length() > 2) {
                        log.fatal("The 's/S' option cannot be used in combination with other options");
                        System.exit(1);
                    } else {

                        log.info("generating  Servlets");
                        SERVLET = true;
                    }
                    return;
                }//For option s/S
                if ((arg.substring(1, arg.length()).indexOf("all") != -1) || (arg.substring(1, arg.length()).indexOf("ALL") != -1)) {
                    if (arg.length() > 4) {
                        log.fatal("The 'all/ALL' option cannot be used in combination with other options");
                        System.exit(1);
                    } else {
                        log.info("generation All Except the jen-desc.xml");
                        REMOTE = true;
                        HOME = true;
                        BEAN = true;
                        DD = true;
                    }
                    return;
                }//For option all/All
                if ((arg.substring(1, arg.length()).indexOf("r") != -1) || (arg.substring(1, arg.length()).indexOf("R") != -1)) {
                    log.info("generating remote interfaces");
                    REMOTE = true;
                }//For option r/R
                if ((arg.substring(1, arg.length()).indexOf("h") != -1) || (arg.substring(1, arg.length()).indexOf("H") != -1)) {
                    log.info("generating home interfaces");
                    HOME = true;
                }//For option h/H
                if ((arg.substring(1, arg.length()).indexOf("b") != -1) || (arg.substring(1, arg.length()).indexOf("B") != -1)) {
                    log.info("generating bean classes");
                    BEAN = true;
                }//For option b/B
                if ((arg.substring(1, arg.length()).indexOf("l") != -1) || (arg.substring(1, arg.length()).indexOf("L") != -1)) {
                    log.info("generating local home and remote interfaces");
                    LOCAL = true;
                }//For option l/L
                if ((arg.substring(1, arg.length()).indexOf("c") != -1) || (arg.substring(1, arg.length()).indexOf("C") != -1)) {
                    log.info("generating  Deployment Descriptor");
                    DD = true;
                }//For option c/C
                if ((arg.substring(1, arg.length()).indexOf("j") != -1) || (arg.substring(1, arg.length()).indexOf("J") != -1)) {
                    log.info("generating  JUnit classes");
                    JUNIT = true;
                }//For option j/J
                if ((arg.substring(1, arg.length()).indexOf("m") != -1) || (arg.substring(1, arg.length()).indexOf("M") != -1)) {
                    log.info("generating  build.xml file");
                    ANT = true;
                }//For option m/M
                if ((arg.substring(1, arg.length()).indexOf("o") != -1) || (arg.substring(1, arg.length()).indexOf("O") != -1)) {
                    log.info("generating  JDO related source and descriptor");
                    JDO = true;
                }//For option o/O
                if ((arg.substring(1, arg.length()).indexOf("u") != -1) || (arg.substring(1, arg.length()).indexOf("U") != -1)) {
                    log.info("generating  Unit tests for classes other than EJB's");
                    UNIT_TESTS = true;
                }//For option o/O

            } else {
                log.fatal("Options should start with '-' . For Example : '-r'");
                printUsage();
                System.exit(1);
            }

        }


    }//parseArgs

    /**
     * printUsage
     * The method which prints the right usage of the command line arguments
     */
    public void printUsage() {
        System.err.println("usage : java com.jenerator.Jenerator (options)\n");
        System.err.println("options: ");
        System.err.println("-d \\ -D	   Generate the Descriptor for the Jenerator");
        System.err.println("                Note:- This option cannot be used in combination with other options");
        System.err.println("-r \\ -R	   Generate the Remote Interfaces");
        System.err.println("-b \\ -B	   Generate the Bean Classes");
        System.err.println("-h \\ -H	   Generate the Home Interfaces");
        System.err.println("-l \\ -L	   Generate the local and local home Interfaces");
        System.err.println("-c \\ -C	   Generate the EJB Deployment Descriptor - ejb-jar.xml");
        System.err.println("-j \\ -J    Generate Unit tests for EJB's");
        System.err.println("-m \\ -M    Generate ANT's build.xml file for the generated code");
        System.err.println("-p \\ -P    Generate GOF and J2EE Patterns");
        System.err.println("-s \\ -S    Generate Servlets");
        System.err.println("-o \\ -O    Generate JDO Source and the respective .jdo descriptor");
        System.err.println("-all \\ -ALL  Same as -rbhc | -RBHC");
        System.err.println("                 Note:- This option cannot be used in combination with other options");
    }//printUsage

}//ArgumentParser