View Javadoc
   /*
    */
   package net.sf.panoptes.model.component.registry;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.Enumeration;
   import java.util.Hashtable;
   import java.util.Iterator;
  
  /***
   * Represents the IComponent reference. Original code from JBoss.
   *
   * @see net.sf.panoptes.model.component.registry.ComponentRegistry
   *
   * @author  dag@liodden.no
   * @version 0.1
   *
   */
  public class ComponentName implements java.io.Serializable {
  
  	public static final String DOMAIN_COMPONENT_QUERY = "query";
  	public static final String DOMAIN_MBEAN_DOMAIN = "jmx.domain";
  	public static final String DOMAIN_MBEAN_SERVER = "jmx.server";
  	public static final String DOMAIN_MBEAN = "jmx.mbean";
  	public static final String DOMAIN_LOGGER = "logger";
  
  	// Attributes ----------------------------------------------------
  	private transient boolean hasPattern = false;
  	private transient boolean hasPropertyPattern = false;
  	private transient boolean hasDomainPattern = false;
  	private transient Hashtable propertiesHash = null;
  
  	private transient String domain = null;
  	private transient String kProps = null;
  	private transient String ckProps = null;
  
  	private transient int hash;
  
  	// Static --------------------------------------------------------
  
  	// Constructors --------------------------------------------------
  	public ComponentName(String name) throws MalformedComponentNameException {
  		init(name);
  	}
  
  	public ComponentName(String domain, String name) throws MalformedComponentNameException {
  		init(domain + ":" + name);
  	}
  
  	public ComponentName(String domain, Hashtable table) throws MalformedComponentNameException {
  		if (table == null)
  		   throw new NullPointerException("null table");
  
  		initDomain(domain, null);
  
  		if (table.size() < 1)
  		   throw new MalformedComponentNameException("empty table");
  
  		initProperties((Hashtable) table.clone(), null);
  
  		this.kProps = ckProps;
  	}
  
  	// Public ------------------------------------------------------
  	/***
  	 * Quotes the passed string suitable for use as a value in an
  	 * ObjectName.
  	 *
  	 * @param value the string to quote
  	 * @return the quoted string
  	 * @exception NullPointerException for a null string
  	 */
  	public static String quote(String value) {
  		if (value == null)
  			throw new NullPointerException("null value");
  
  		StringBuffer buffer = new StringBuffer(value.length() + 10);
  		buffer.append('"');
  		char[] chars = value.toCharArray();
  		for (int i = 0; i < chars.length; i++) {
  			switch (chars[i]) {
  				case '"' :
  				case '*' :
  				case '?' :
  				case '//' :
  					buffer.append('//').append(chars[i]);
  					break;
  				case '\n' :
  					buffer.append('//').append('n');
  					break;
  				default :
  					buffer.append(chars[i]);
  			}
  		}
  		buffer.append('"');
  
  		return buffer.toString();
  	}
 
 	/***
 	 * Unquotes a string, unquote(quote(s)).equals(s) is always true.
 	 *
 	 * @param value the string to unquote
 	 * @return the unquoted string
 	 * @exception IllegalArgumentException when the string is
 	 *            not of a form that can be unquoted.
 	 * @exception NullPointerException for a null string
 	 */
 	public static String unquote(String value) {
 		if (value == null)
 			throw new NullPointerException("null value");
 		if (value.length() == 0)
 			throw new IllegalArgumentException("Empty value");
 
 		StringBuffer buffer = new StringBuffer(value.length());
 
 		char[] chars = value.toCharArray();
 
 		boolean inQuote = false;
 		boolean escape = false;
 
 		for (int i = 0; i < chars.length; ++i) {
 			// Valid escape character?
 			char c = chars[i];
 			if (escape) {
 				switch (c) {
 					case '//' :
 					case '"' :
 					case '*' :
 					case '?' :
 						escape = false;
 						buffer.append(c);
 						break;
 					case 'n' :
 						escape = false;
 						buffer.append('\n');
 						break;
 
 						// Invalid escape character
 					default :
 						throw new IllegalArgumentException(
 							"The value " + value + " contains an invalid escape sequence backslash " + c);
 				}
 			}
 
 			// Starting a quote
 			else if (inQuote == false && c == '"')
 				inQuote = true;
 
 			// Ending a quote
 			else if (inQuote && c == '"')
 				inQuote = false;
 
 			// Escaping
 			else if (inQuote && c == '//')
 				escape = true;
 
 			// Inside a quote
 			else if (inQuote) {
 				switch (c) {
 					case '"' :
 						throw new IllegalArgumentException(
 							"The value " + value + " cannot contain quote inside a quote pair, use backslash quote");
 					case '*' :
 					case '?' :
 						throw new IllegalArgumentException(
 							"The value " + value + " cannot contain " + c + " inside a quote pair, use backslash " + c);
 					case '\n' :
 						throw new IllegalArgumentException(
 							"The value " + value + " cannot contain a new line inside a quote pair, use backslash n");
 				}
 				buffer.append(c);
 			}
 
 			// Plain text
 			else
 				throw new IllegalArgumentException("The value " + value + " is not enclosed in quotes");
 		}
 
 		if (inQuote)
 			throw new IllegalArgumentException("Unterminated quote pair, missing quote");
 		if (escape)
 			throw new IllegalArgumentException("Unterminated escape, missing one of backslash quote asterisk question mark or n");
 
 		return buffer.toString();
 	}
 
 	public boolean equals(Object object) {
 		if (object == this) {
 			return true;
 		}
 
 		if (object instanceof ComponentName) {
 			ComponentName oname = (ComponentName) object;
 			return (oname.hash == hash && domain.equals(oname.domain) && ckProps.equals(oname.ckProps));
 		}
 
 		return false;
 	}
 
 	public int hashCode() {
 		return hash;
 	}
 
 	public String toString() {
 		return this.domain + ":" + ckProps;
 	}
 
 	public boolean isPattern() {
 		return hasPattern;
 	}
 
 	public String getCanonicalName() {
 		return this.domain + ":" + ckProps;
 	}
 
 	public String getDomain() {
 		return domain;
 	}
 
 	public String getKeyProperty(String property) {
 		return (String) propertiesHash.get(property);
 	}
 
 	public Hashtable getKeyPropertyList() {
 		return (Hashtable) propertiesHash.clone();
 	}
 
 	public String getKeyPropertyListString() {
 		return kProps;
 	}
 
 	public String getCanonicalKeyPropertyListString() {
 		return ckProps;
 	}
 
 	public boolean isPropertyPattern() {
 		return hasPropertyPattern;
 	}
 
 	// Private -----------------------------------------------------
 
 	/***
 	 * constructs an object name from a string
 	 */
 	private void init(String name) throws MalformedComponentNameException {
 		if (name == null)
 			throw new NullPointerException("null name");
 
 		if (name.length() == 0)
 			name = "*:*";
 
 		int domainSep = name.indexOf(':');
 
 		if (-1 == domainSep)
 			throw new MalformedComponentNameException("missing domain");
 
 		initDomain(name.substring(0, domainSep), name);
 		initProperties(name.substring(domainSep + 1), name);
 	}
 
 	/***
 	  * checks for domain patterns and illegal characters
 	  */
 	 private void initDomain(String dstring, String name) throws MalformedComponentNameException
 	 {
 		if (null == dstring)
 		   throw new NullPointerException("null domain");
 
 		checkIllegalDomain(dstring, name);
 
 		if (dstring.indexOf('*') > -1 || dstring.indexOf('?') > -1)
 		{
 		   this.hasPattern = true;
 		   this.hasDomainPattern = true;
 		}
 
 		this.domain = dstring;
 	 }
 	/***
 	 * takes the properties string and breaks it up into key/value pairs for
 	 * insertion into a newly created hashtable.
 	 *
 	 * minimal validation is performed so that it doesn't blow up when
 	 * constructing the kvp strings.
 	 *
 	 * checks for duplicate keys
 	 *
 	 * detects property patterns
 	 *
 	 */
 	private void initProperties(String properties, String name) throws MalformedComponentNameException {
 		if (null == properties || properties.length() < 1)
 			throw new MalformedComponentNameException(addDebugObjectName(name) + "null or empty properties");
 
 		Hashtable ptable = new Hashtable();
 
 		char[] chars = properties.toCharArray();
 
 		String key = null;
 		String value = null;
 		int start = 0;
 		boolean inKey = true;
 		boolean inQuote = false;
 		boolean escape = false;
 
 		for (int current = 0; current < chars.length; ++current) {
 			char c = chars[current];
 
 			// Previous character was the backslash escape
 			if (escape)
 				escape = false;
 
 			// In a quote
 			else if (inQuote) {
 				// End the quote
 				if (c == '"')
 					inQuote = false;
 
 				// Start escaping
 				else if (c == '//')
 					escape = true;
 			}
 
 			// Processing the key
 			else if (inKey) {
 				// Found the terminator
 				if (c == '=' || c == ',') {
 					if (current == start)
 						throw new MalformedComponentNameException(addDebugObjectName(name) + "Empty key");
 					key = properties.substring(start, current);
 
 					// Didn't get an equals so the only thing valid is asterisk
 					if (c == ',') {
 						if (key.equals("*")) {
 							if (hasPropertyPattern)
 								throw new MalformedComponentNameException(
 									addDebugObjectName(name) + "A property pattern may only contain one * property");
 							this.hasPropertyPattern = true;
 							this.hasPattern = true;
 						} else
 							throw new MalformedComponentNameException(
 								addDebugObjectName(name) + "Invalid key/value data " + key);
 					} else {
 						// Check for a duplicate key and process the value
 						if (ptable.containsKey(key))
 							throw new MalformedComponentNameException(addDebugObjectName(name) + "Duplicate key " + key);
 						inKey = false;
 					}
 					start = current + 1;
 				}
 			}
 
 			// Processing a value
 			else {
 				// Starting a quote
 				if (c == '"')
 					inQuote = true;
 
 				// Found the terminator
 				else if (c == ',') {
 					// Add the key, value pair and process the next pair
 					if (current == start)
 						ptable.put(key, "");
 					else
 						ptable.put(key, properties.substring(start, current));
 
 					inKey = true;
 					start = current + 1;
 				}
 			}
 		}
 
 		// Fell off the end while processing a key
 		if (inKey) {
 			if (start == chars.length)
 				throw new MalformedComponentNameException(
 					addDebugObjectName(name) + "An ObjectName cannot end with a comma");
 
 			// Might be ok if the remainder is an asterisk
 			key = properties.substring(start, chars.length);
 			if (key.equals("*")) {
 				if (hasPropertyPattern)
 					throw new MalformedComponentNameException(
 						addDebugObjectName(name) + "A property pattern may only contain one * property");
 
 				this.hasPropertyPattern = true;
 				this.hasPattern = true;
 			} else
 				throw new MalformedComponentNameException(addDebugObjectName(name) + "Invalid key/value data " + key);
 		}
 
 		// Fell off the end while processing a value
 		if (inKey == false) {
 			// No value
 			if (start == chars.length)
 				ptable.put(key, "");
 			else
 				ptable.put(key, properties.substring(start, chars.length));
 		}
 
 		initProperties(ptable, name);
 		this.kProps = properties;
 	}
 
 	/***
 	 * validates incoming properties hashtable
 	 *
 	 * builds canonical string
 	 *
 	 * precomputes the hashcode
 	 */
 	private void initProperties(Hashtable properties, String name) throws MalformedComponentNameException {
 		if (null == properties || (!this.hasPropertyPattern && properties.size() < 1))
 			throw new MalformedComponentNameException(addDebugObjectName(name) + "null or empty properties");
 
 		Iterator it = properties.keySet().iterator();
 		ArrayList list = new ArrayList();
 
 		while (it.hasNext()) {
 			String key = null;
 			try {
 				key = (String) it.next();
 			} catch (ClassCastException e) {
 				throw new MalformedComponentNameException(addDebugObjectName(name) + "key is not a string " + key);
 			}
 
 			String val = null;
 			try {
 				val = (String) properties.get(key);
 			} catch (ClassCastException e) {
 				throw new MalformedComponentNameException(addDebugObjectName(name) + "value is not a string " + val);
 			}
 
 			if (key.equals("*") && val.equals("*")) {
 				it.remove();
 				this.hasPropertyPattern = true;
 				this.hasPattern = true;
 				continue;
 			}
 
 			if (key.length() == 0)
 				throw new MalformedComponentNameException(addDebugObjectName(name) + "key has no length =" + val);
 
 			checkIllegalKey(key, name);
 			checkIllegalValue(val, name);
 
 			list.add(new String(key + "=" + val));
 		}
 
 		Collections.sort(list);
 		StringBuffer strBuffer = new StringBuffer();
 
 		it = list.iterator();
 		while (it.hasNext()) {
 			strBuffer.append(it.next());
 			if (it.hasNext()) {
 				strBuffer.append(',');
 			}
 		}
 
 		if (this.hasPropertyPattern) {
 			if (properties.size() > 0) {
 				strBuffer.append(",*");
 			} else {
 				strBuffer.append("*");
 			}
 		}
 
 		this.propertiesHash = properties;
 		this.ckProps = strBuffer.toString();
 		this.hash = getCanonicalName().hashCode();
 	}
 
 	private void checkIllegalKey(String key, String name) throws MalformedComponentNameException {
 		char[] chars = key.toCharArray();
 
 		for (int i = 0; i < chars.length; ++i) {
 			switch (chars[i]) {
 				case ':' :
 				case ',' :
 				case '=' :
 				case '*' :
 				case '?' :
 					throw new MalformedComponentNameException(
 						addDebugObjectName(name) + "The key " + key + " cannot contain a " + chars[i] + " character");
 				case '\n' :
 					throw new MalformedComponentNameException(
 						addDebugObjectName(name) + "The key " + key + " cannot contain a new line character");
 			}
 		}
 	}
 
 	private void checkIllegalValue(String value, String name) throws MalformedComponentNameException {
 		char[] chars = value.toCharArray();
 
 		boolean inQuote = false;
 		boolean escape = false;
 
 		for (int i = 0; i < chars.length; ++i) {
 			// Valid escape character?
 			char c = chars[i];
 			if (escape) {
 				switch (c) {
 					case '//' :
 					case 'n' :
 					case '"' :
 					case '*' :
 					case '?' :
 						escape = false;
 						break;
 
 						// Invalid escape character
 					default :
 						throw new MalformedComponentNameException(
 							addDebugObjectName(name)
 								+ "The value "
 								+ value
 								+ " contains an invalid escape sequence backslash "
 								+ c);
 				}
 			}
 
 			// Starting a quote
 			else if (inQuote == false && c == '"')
 				inQuote = true;
 
 			// Ending a quote
 			else if (inQuote && c == '"')
 				inQuote = false;
 
 			// Escaping
 			else if (inQuote && c == '//')
 				escape = true;
 
 			// Inside a quote
 			else if (inQuote) {
 				switch (c) {
 					case '"' :
 						throw new MalformedComponentNameException(
 							addDebugObjectName(name)
 								+ "The value "
 								+ value
 								+ " cannot contain quote inside a quote pair, use backslash quote");
 					case '*' :
 					case '?' :
 						throw new MalformedComponentNameException(
 							addDebugObjectName(name)
 								+ "The value "
 								+ value
 								+ " cannot contain "
 								+ c
 								+ " inside a quote pair, use backslash "
 								+ c);
 					case '\n' :
 						throw new MalformedComponentNameException(
 							addDebugObjectName(name)
 								+ "The value "
 								+ value
 								+ " cannot contain a new line inside a quote pair, use backslash n");
 				}
 			}
 
 			// Plain text
 			else {
 				switch (c) {
 					case ':' :
 					case ',' :
 					case '=' :
 					case '*' :
 					case '?' :
 						throw new MalformedComponentNameException(
 							addDebugObjectName(name)
 								+ "The value "
 								+ value
 								+ " cannot contain "
 								+ c
 								+ " use quote backslash "
 								+ c
 								+ " quote or ObjectName.quote(String)");
 					case '\n' :
 						throw new MalformedComponentNameException(
 							addDebugObjectName(name)
 								+ "The value "
 								+ value
 								+ " cannot contain a new line use quote backslash n quote or ObjectName.quote(String)");
 				}
 			}
 		}
 
 		if (inQuote)
 			throw new MalformedComponentNameException(
 				addDebugObjectName(name) + "Unterminated quote pair, missing quote");
 		if (escape)
 			throw new MalformedComponentNameException(
 				addDebugObjectName(name)
 					+ "Unterminated escape, missing one of backslash quote asterisk question mark or n");
 	}
 
 	/***
 	 * returns true if the domain contains illegal characters
 	 */
 	private void checkIllegalDomain(String dom, String name) throws MalformedComponentNameException {
 		char[] chars = dom.toCharArray();
 
 		for (int i = 0; i < chars.length; i++) {
 			switch (chars[i]) {
 				case ':' :
 					throw new MalformedComponentNameException(
 						addDebugObjectName(name) + "The domain " + dom + " cannot contain a : character");
 				case '\n' :
 					throw new MalformedComponentNameException(
 						addDebugObjectName(name) + "The domain " + dom + " cannot contain a new line character");
 			}
 		}
 	}
 
 	private String addDebugObjectName(String name) {
 		if (name == null)
 			return "";
 		else
 			return name + " is not a valid ObjectName. ";
 	}
 
 	/***
 	 * @param string
 	 */
 	public void setDomain(String domain) throws MalformedComponentNameException {
 		initDomain(domain, null);
 	}
 
 	/***
 	 * Checks if this instance matches a pattern.
 	 * 
 	 * @param pattern the pattern
 	 * @return true if it matches
 	 */
 	public boolean matches(ComponentName pattern) {
 		// We do casts here without any checking since the keys and values have been
 		// checked in the ComponentName constructor.
 
 		// Check if the domain matches
 		if ((!pattern.getDomain().equals("*") && !pattern.getDomain().equals(getDomain())))
 			return false;
 
 		// Check the keys in pattern and see if there is a match;
 		Hashtable props = pattern.getKeyPropertyList();
 		for (Enumeration e = props.keys(); e.hasMoreElements();) {
 			String key = (String) e.nextElement();
 			String value = (String) propertiesHash.get(key);
 			if ((value == null) || !(value.equals(props.get(key))))
 				return false;
 		}
 		return true;
 	}
 }