24 Oct 2014

CleaningCode4_Args

	public static void main(String[] args) {
		try{
			Args arg = new Args("l,p#,d*", args);
			boolean logging = arg.getBoolean('1');
			int port = arg.getInt('p');
			String directory = arg.getString('d');
			executeApplication(logging, port, directory);
		}catch (ArgsException e) {
			System.out.printf("Argument error:%s\n",e.errorMessage());
		}
	}

	public class Args{
		private Map<Character, ArgumentMarshaler> marshalers;
		private Set<Character> argsFound;
		private ListIterator<String> currentArgument;
		
		public Args(String schema, String[] args) throws ArgsException {
			marshalers = new HashMap<Character, ArgumentMarshaler>();
			argsFound = new HashSet<Character>();
			
			parseSchema(schema);
			parseArgumentStrings(Arrays.asList(args));
		}
		
		private void parseSchema(String schema) throws ArgsException {
			for(String element : schema.split(","))
				if(element.length() > 0)
					parseSchemaElement(element.trim());
		}
	}
	
	private void parseSchemaElement(String element) throws ArgsException {
		char elementId = element.charAt(0);
		String elementTail = element.substring(1);
		validateSchemaElementId(elementId);
		if(elementTail.length() == 0)
			marshalers.put(elementId, new BooleanArgumentMarshaler());
		else if(elementTail.equals("*"))
			marshalers.put(elementId, new StringArgumentMarshaler());
		else if(elementTail.equals("#"))
			marshalers.put(elementId, new IntegerArgumentMarshaler());
		else if(elementTail.equals("##"))
			marshalers.put(elementId, new DoubleArgumentMarshaler());
		else if(elementTail.equals("[*]"))
			marshalers.put(elementId, new StringArrayArgumentMarshaler());
		else 
			throw new ArgsException(INVALID_ARGUMENT_FORMAT, elementId, elementTail);
	}
	
	private void validateSchemaElementId(char elementId) throws ArgsException {
		if(!Character.isLetter(elementId))
			throws new ArgsException(INVALID_ARGUMENT_NAME, elementId, null);
	}
	
	private void parseArgumentStrings(List<String> argsList) throws ArgsException {
		for(currentArgument = argsList.listIterator(); currentArgument.hasNext();){
			String argString = currentArgument.next();
			if(argString.startsWith("-")) {
				parseArgumentCharacters(argString.substring(1));
			}else {
				currentArgument.previous();
				break;
			}
		}
	}
	
	private void parseArgumentCharacters(String srgChars) throws ArgsException {
		for(int i = 0; i < argChars.length(); i++)
			parseArgumentCharacter(argChars.charAt(i));
	}
	
	private void parseArgumentCharacter(char argChar) throws ArgsException{
		ArgumentMarshaler m = marshalers.get(argChar);
		if (m == null) {
			throw new ArgsException(UNEXPECTED_ARGUMENT, argChar, null);
		} else {
			argsFound.add(argChar);
			try {
				m.set(currentArgument);
			} catch (ArgsException e) {
				e.setErrorArgumenetId(argChar);
				throw e;
			}
		}
	}
	
	public boolean has(char arg) {
		return argsFound.contains(arg);
	}
	
	public int nextArgument() {
		return currentArgument.nextIndex();
	}
	
	public boolean getBoolean(char arg) {
		return BooleanArgumentMarshaler.getValue(marshalers.get(arg));
	}
	
	public String getString(char arg) {
		return StringArgumentMarshaler.getValue(marshalers.get(arg)); 
	}
	
	public int getInt(char arg) {
		return IntegerArgumentMarshaler.getValue(marshalers.get(arg)); 
	}
	
	public double getDouble(char arg) {
		return DoubleArgumentMarshaler.getValue(marshalers.get(arg)); 
	}
	
	public String[] getStringArray(char arg) {
		return StringArrayArgumentMarshaler.getValue(marshalers.get(arg)); 
	}

乐此不疲～