Parser style improvements

git-svn-id: http://svn.dmdirc.com/trunk@1968 00569f92-eb28-0410-84fd-f71c24880f

src/com/dmdirc/parser/ProcessWho.java

 
 package com.dmdirc.parser;
 
-import java.util.Enumeration;
-
-import com.dmdirc.parser.ClientInfo;
-import com.dmdirc.parser.ChannelClientInfo;
-import com.dmdirc.parser.ChannelInfo;
 import com.dmdirc.parser.callbacks.CallbackOnAwayStateOther;
-import com.dmdirc.parser.callbacks.interfaces.IAwayStateOther;
 import com.dmdirc.parser.callbacks.CallbackOnChannelAwayStateOther;
-import com.dmdirc.parser.callbacks.interfaces.IChannelAwayStateOther;
 
 /**
  * Process a /who reply
 	 * @param sParam Type of line to process ("352")
 	 * @param token IRCTokenised line to process
 	 */
-	public void process(String sParam, String[] token) {
+	public void process(final String sParam, final String[] token) {
 		// :blueyonder2.uk.quakenet.org 352 Dataforce #mdbot shane Tobavaj.users.quakenet.org *.quakenet.org Tobavaj G+x :3 Tobavaj - http://shane.dmdirc.com/scriptbot.php
 		//              0               1      2        3     4              5                      6           7     8        9
 		// :blueyonder2.uk.quakenet.org 352 Dataforce #mdbot ~Dataforce ResNetUser-BrynDinas-147.143.246.102.bangor.ac.uk *.quakenet.org Dataforce H@ :0 Dataforce
 //		ChannelInfo channel = myParser.getChannelInfo(token[3]);
 //		ChannelClientInfo channelClient = channel.getUser(token[7]);
 //		ClientInfo client = channelClient.getClient();
-		ClientInfo client = myParser.getClientInfo(token[7]);
+		final ClientInfo client = myParser.getClientInfo(token[7]);
 		if (client != null) {
 			// Update ident/host
 			client.setUserBits(token[7]+"!"+token[4]+"@"+token[5], false);
 			// Update real name
 			if (client.getRealName().equals("")) {
 				try {
-					String name = token[9].split(" ", 2)[1];
+					final String name = token[9].split(" ", 2)[1];
 					client.setRealName(name);
 				} catch (Exception e) { /* Do Nothing */ }
 			}
 			// Update away state
-			String mode = token[8];
-			boolean isAway = mode.matches(".*G.*");
+			final String mode = token[8];
+			final boolean isAway = mode.indexOf('G') != -1;
 			if (client.getAwayState() != isAway) {
 //				System.out.println("Away state for '"+client+"' changed to: "+isAway);
 				client.setAwayState(isAway);
 				callAwayStateOther(client, isAway);
 				
-				ChannelInfo iChannel;
 				ChannelClientInfo iChannelClient;
-				for (Enumeration e = myParser.hChannelList.keys(); e.hasMoreElements();) {
-					iChannel = myParser.hChannelList.get(e.nextElement());
+				for (ChannelInfo iChannel : myParser.hChannelList.values()) {
 					iChannelClient = iChannel.getUser(client);
 					if (iChannelClient != null) {
 						callChannelAwayStateOther(iChannel,iChannelClient,isAway);
 	 * @param state Away State (true if away, false if here)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callAwayStateOther(ClientInfo client, boolean state) {
-		CallbackOnAwayStateOther cb = (CallbackOnAwayStateOther)myParser.getCallbackManager().getCallbackType("OnAwayStateOther");
+	protected boolean callAwayStateOther(final ClientInfo client, final boolean state) {
+		final CallbackOnAwayStateOther cb = (CallbackOnAwayStateOther)myParser.getCallbackManager().getCallbackType("OnAwayStateOther");
 		if (cb != null) { return cb.call(client, state); }
 		return false;
 	}
 	 * @param state Away State (true if away, false if here)
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callChannelAwayStateOther(ChannelInfo channel, ChannelClientInfo channelClient, boolean state) {
-		CallbackOnChannelAwayStateOther cb = (CallbackOnChannelAwayStateOther)myParser.getCallbackManager().getCallbackType("OnChannelAwayStateOther");
+	protected boolean callChannelAwayStateOther(final ChannelInfo channel, final ChannelClientInfo channelClient, final boolean state) {
+		final CallbackOnChannelAwayStateOther cb = (CallbackOnChannelAwayStateOther)myParser.getCallbackManager().getCallbackType("OnChannelAwayStateOther");
 		if (cb != null) { return cb.call(channel, channelClient, state); }
 		return false;
 	}

src/com/dmdirc/parser/ProcessingManager.java

  */
 
 package com.dmdirc.parser;
-import com.dmdirc.parser.callbacks.interfaces.INumeric;
+
 import com.dmdirc.parser.callbacks.CallbackOnNumeric;
+
 import java.util.Hashtable;
-import java.util.Enumeration;
 
 /**
  * IRC Parser Processing Manager.
 	IRCParser myParser = null;
 	
 	/** Hashtable used to store the different types of IRCProcessor known. */
-	private Hashtable<String,IRCProcessor> processHash = new Hashtable<String,IRCProcessor>();
+	private final Hashtable<String,IRCProcessor> processHash = new Hashtable<String,IRCProcessor>();
 
 	/**
 	 * Constructor to create a ProcessingManager
 	/**
 	 * Debugging Data to the console.
 	 */
-	private void DoDebug(String line, Object... args) {
+	private void DoDebug(final String line, final Object... args) {
 		myParser.callDebugInfo(myParser.DEBUG_PROCESSOR, line, args);
 	}
 	
 	public void empty() {
 		processHash.clear();
 	}
-	
-	/** Empty clone method to prevent cloning to get more copies of the ProcessingManager */
-	public Object clone() throws CloneNotSupportedException {
-		throw new CloneNotSupportedException();
-	}
 
 	/**
 	 * Add new Process type.
 	 *
 	 * @param processor IRCProcessor subclass for the processor.
 	 */
-	public void addProcessor(IRCProcessor processor) {	
+	public void addProcessor(final IRCProcessor processor) {	
 		// handles() returns a String array of all the tokens
 		// that this processor will parse.
 		addProcessor(processor.handles(), processor);
 	 * @param processor IRCProcessor subclass for the processor.
 	 * @param handles String Array of tokens to add this processor as a hadler for
 	 */
-	public void addProcessor(String[] handles, IRCProcessor processor) {	
+	public void addProcessor(final String[] handles, final IRCProcessor processor) {	
 		DoDebug("Adding processor: "+processor.getName());
 		
 		try {
 	 *
 	 * @param processor IRCProcessor subclass for the processor.
 	 */
-	public void delProcessor(IRCProcessor processor) {	
+	public void delProcessor(final IRCProcessor processor) {	
 		IRCProcessor testProcessor;
-		String elementName;
 		DoDebug("Deleting processor: "+processor.getName());
-		for (Enumeration e = processHash.keys(); e.hasMoreElements();) {
-			elementName = (String)e.nextElement();
+		for (String elementName : processHash.keySet()) {
 			DoDebug("\t Checking handler for: "+elementName);
 			testProcessor = processHash.get(elementName);
 			if (testProcessor.getName().equalsIgnoreCase(processor.getName())) {
 	 * @param sParam Type of line to process ("005", "PRIVMSG" etc)
 	 * @return IRCProcessor for the given param.
 	 */
-	public IRCProcessor getProcessor(String sParam) throws ProcessorNotFound {
+	public IRCProcessor getProcessor(final String sParam) throws ProcessorNotFound {
 		if (processHash.containsKey(sParam.toLowerCase())) {
 			return processHash.get(sParam.toLowerCase());
 		} else {
 	 * @param token IRCTokenised line to process
 	 * @throws ProcessorNotFound exception if no processors exists to handle the line
 	 */
-	public void process(String sParam, String[] token) throws ProcessorNotFound {
+	public void process(final String sParam, final String[] token) throws ProcessorNotFound {
 		IRCProcessor messageProcessor = null;
 		try {
 			messageProcessor = getProcessor(sParam);
 		} catch (ProcessorNotFound p) {
 			throw p;
 		} catch (Exception e) {
-			StringBuilder line = new StringBuilder();
+			final StringBuilder line = new StringBuilder();
 			for (int i = 0; i < token.length; ++i ) { line.append(" ").append(token[i]); }
-			ParserError ei = new ParserError(ParserError.ERROR_WARNING,"Exception in Parser. [Param: "+sParam+"] [Processor: "+messageProcessor+"]", line.toString().trim());
+			final ParserError ei = new ParserError(ParserError.ERROR_WARNING,"Exception in Parser. [Param: "+sParam+"] [Processor: "+messageProcessor+"]", line.toString().trim());
 			ei.setException(e);
 			myParser.callErrorInfo(ei);
 		} finally {
 	 * @param token IRC Tokenised line
 	 * @return true if a method was called, false otherwise
 	 */
-	protected boolean callNumeric(int numeric, String[] token) {
-		CallbackOnNumeric cb = (CallbackOnNumeric)myParser.getCallbackManager().getCallbackType("OnNumeric");
+	protected boolean callNumeric(final int numeric, final String[] token) {
+		final CallbackOnNumeric cb = (CallbackOnNumeric)myParser.getCallbackManager().getCallbackType("OnNumeric");
 		if (cb != null) { return cb.call(numeric, token); }
 		return false;
 	}

src/com/dmdirc/parser/ProcessorNotFound.java

 	 *
 	 * @param message Reason for exception
 	 */
-	public ProcessorNotFound(String message) { super(message); }
+	public ProcessorNotFound(final String message) { super(message); }
 	
 	/**
 	 * Get SVN Version information.

src/com/dmdirc/parser/RegexStringList.java

  * @version $Id$
  */
 public class RegexStringList {
+	
 	/** Arraylist storing ignore patterns */
-	private ArrayList<String> ignoreInfo = new ArrayList<String>();
+	private final ArrayList<String> ignoreInfo = new ArrayList<String>();
 	
 	/**
 	 * Add a new ignore pattern to the ignore list.
 	 *
 	 * @param pattern Regex syntax for the ignore (Pattern is matched case-insensitively as ^pattern$)
 	 */
-	public void add(String pattern) {
+	public void add(final String pattern) {
 		for (int i = 0; i < this.count(); ++i) {
 			if (pattern.equalsIgnoreCase(this.get(i))) {
 				return;
 	 *
 	 * @param position Position in the list to remove
 	 */
-	public void remove(int position) {
+	public void remove(final int position) {
 		if (position < this.count()) {
 			ignoreInfo.remove(position);
 		}
 	 * @param check String to check (Patterns are matched case-insensitively as ^pattern$)
 	 * @return integer showing the position of the first match in the ignore list (-1 if none)
 	 */
-	public int matches(String check) {
+	public int matches(final String check) {
 		for (int i = 0; i < this.count(); ++i) {
 			if (check.matches("(?i)"+this.get(i))) {
 				return i;
 	 * @param check String to check (Patterns are matched case-insensitively as ^pattern$)
 	 * @return boolean true/false
 	 */
-	public boolean matches(int position, String check) {
+	public boolean matches(final int position, final String check) {
 		if (position < this.count()) {
 			return check.matches("(?i)"+this.get(position));
 		} else {
 	 * @param position Position to check
 	 * @return String showing the pattern. ("" if position isn't valid)
 	 */
-	public String get(int position) {
+	public String get(final int position) {
 		if (position < this.count()) {
 			return ignoreInfo.get(position);
 		} else {
 	 * @param position Position to change
 	 * @param pattern New pattern
 	 */
-	public void set(int position, String pattern) {
+	public void set(final int position, final String pattern) {
 		if (position < this.count()) {
 			ignoreInfo.set(position, pattern);
 		}

src/com/dmdirc/parser/ServerInfo.java

 	 *
 	 * @param newValue Value to set to.
 	 */
-	public void setHost(String newValue) { host = newValue; }
+	public void setHost(final String newValue) { host = newValue; }
 	
 	/**
 	 * Get the hostname.
 	 *
 	 * @param newValue Value to set to.
 	 */
-	public void setPort(int newValue) { port = newValue; }
+	public void setPort(final int newValue) { port = newValue; }
 	
 	/**
 	 * Get the port.
 	 *
 	 * @param newValue Value to set to.
 	 */
-	public void setPassword(String newValue) { password = newValue; }
+	public void setPassword(final String newValue) { password = newValue; }
 	
 	/**
 	 * Get the password.
 	 *
 	 * @param newValue true if server uses ssl, else false
 	 */
-	public void setSSL(boolean newValue) { isSSL = newValue; }
+	public void setSSL(final boolean newValue) { isSSL = newValue; }
 	
 	/**
 	 * Get if the server uses ssl.
 	 *
 	 * @param newValue true if we are using socks, else false
 	 */
-	public void setUseSocks(boolean newValue) { useSocksProxy = newValue; }
+	public void setUseSocks(final boolean newValue) { useSocksProxy = newValue; }
 	
 	/**
 	 * Get if we are connecting via a socks proxy.
 	 *
 	 * @param newValue Value to set to.
 	 */
-	public void setProxyHost(String newValue) { proxyHost = newValue; }
+	public void setProxyHost(final String newValue) { proxyHost = newValue; }
 	
 	/**
 	 * Get the Proxy hostname.
 	 *
 	 * @param newValue Value to set to.
 	 */
-	public void setProxyPort(int newValue) { proxyPort = newValue; }
+	public void setProxyPort(final int newValue) { proxyPort = newValue; }
 	
 	/**
 	 * Get the Proxy port.