symboldefinitionset.java

eclipseme的最新版本的source,欢迎j2me程序员使用

/**
 * Copyright (c) 2003-2005 Craig Setera
 * All Rights Reserved.
 * Licensed under the Eclipse Public License - v 1.0
 * For more information see http://www.eclipse.org/legal/epl-v10.html
 */
package eclipseme.core.model;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import eclipseme.core.persistence.IPersistable;
import eclipseme.core.persistence.IPersistenceProvider;
import eclipseme.core.persistence.PersistenceException;

/**
 * A set of symbol names to true/false definition status.
 * <p />
 * Copyright (c) 2003-2005 Craig Setera<br>
 * All Rights Reserved.<br>
 * Licensed under the Eclipse Public License - v 1.0<p/>
 * <br>
 * $Revision: 1.4 $
 * <br>
 * $Date: 2006/11/27 00:58:06 $
 * <br>
 * @author Craig Setera
 */
public class SymbolDefinitionSet implements IPersistable {
	private static final String NAME_KEY = "eclipsemeName";
	private static final String KEYS_KEY = "eclipsemeKeys";
	
	// A parent definition set to be chained...
	private SymbolDefinitionSet parentSet;
	
	private String name;
	private HashMap map;
	
	/**
	 * Construct a new symbol definition set without a name
	 */
	public SymbolDefinitionSet() {
		this((String) null);
	}

	/**
	 * Construct a new symbol definition set with the specified name.
	 * 
	 * @param name
	 */
	public SymbolDefinitionSet(String name) {
		super();
		this.name = name;
		map = new HashMap();
	}
	
	/**
	 * Construct a new symbol definition set with the specified
	 * parent set.
	 * 
	 * @param parentSet
	 */
	public SymbolDefinitionSet(SymbolDefinitionSet parentSet) {
		this((String) null);
		this.parentSet = parentSet;
	}
	
	/**
	 * Define the specified identifier.
	 * 
	 * @param identifier
	 */
	public void define(String identifier) {
		map.put(identifier, Boolean.TRUE);
	}

	/**
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object obj) {
		return 
			(obj instanceof SymbolDefinitionSet) && 
			equals((SymbolDefinitionSet) obj);
	}

	/**
	 * Return a boolean indicating whether the specified SymbolDefinitions
	 * object is equal to this object.
	 * 
	 * @param definitions
	 * @return
	 */
	public boolean equals(SymbolDefinitionSet definitions) {
		return
			safeEquals(name, definitions.name) &&
			safeEquals(map, definitions.map);
	}
	
	/**
	 * Return the symbols that are defined as true in the list of
	 * symbol definitions.  The list of symbols returned by this method
	 * does not include symbols from parent symbol definition sets.
	 * 
	 * @return
	 */
	public String[] getDefinedSymbols() {
		ArrayList defined = new ArrayList();
		
		Iterator keys = map.keySet().iterator();
		while (keys.hasNext()) {
			String key = (String) keys.next();
			if (isDefined(key)) {
				defined.add(key);
			}
		}
		
		return (String[]) defined.toArray(new String[defined.size()]);
	}
	
	/**
	 * Return the name of this set of symbol definitions.
	 * 
	 * @return the name
	 */
	public String getName() {
		return ((name == null) && (parentSet != null)) ? parentSet.getName() : name;
	}

	/**
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {
		return safeHash(name) ^ safeHash(map);
	}

	/**
	 * Return a boolean indicating whether the specified identifier
	 * is defined.
	 * 
	 * @param identifier
	 * @return
	 */
	public boolean isDefined(String identifier) {
		boolean defined = false;
		
		Boolean value = (Boolean) map.get(identifier);
		if (value != null) {
			defined = value.booleanValue();
		} else if (parentSet != null) {
			defined = parentSet.isDefined(identifier);
		}
		
		return defined;
	}

	/**
	 * @see eclipseme.core.persistence.IPersistable#loadUsing(eclipseme.core.persistence.IPersistenceProvider)
	 */
	public void loadUsing(IPersistenceProvider persistenceProvider) 
		throws PersistenceException 
	{
		// Load the name of this definitions object
		name = persistenceProvider.loadString(NAME_KEY);
		
		map.clear();
		String keyString = persistenceProvider.loadString(KEYS_KEY + getStorableName());
		if ((keyString != null) && (keyString.length() > 0)) {
			String[] keys = keyString.split(",");
			for (int i = 0; i < keys.length; i++) {
				String key = keys[i];
				Boolean value = Boolean.valueOf(persistenceProvider.loadBoolean(key));
				map.put(key, value);
			}
		}
	}

	/**
	 * Set the definitions set to contain the specified definitions.
	 * 
	 * @param definitions
	 */
	public void setDefinitions(String[] definitions) {
		map.clear();
		
		for (int i = 0; i < definitions.length; i++) {
			define(definitions[i]);
		}
	}
	
	/**
	 * Set the name of this set of symbol definitions.
	 * 
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * @see eclipseme.core.persistence.IPersistable#storeUsing(eclipseme.core.persistence.IPersistenceProvider)
	 */
	public void storeUsing(IPersistenceProvider persistenceProvider) 
		throws PersistenceException 
	{
		// Store off the name of this definitions object
		persistenceProvider.storeString(NAME_KEY, name);
		
		// Store off the entries in the object
		StringBuffer sb = new StringBuffer();
		Iterator entries = map.entrySet().iterator();
		while (entries.hasNext()) {
			Map.Entry entry = (Map.Entry) entries.next();
			
			// Add the key to the list of keys
			String key = (String) entry.getKey();
			sb.append(key);
			if (entries.hasNext()) {
				sb.append(",");
			}
			
			// Add the entry to the object
			persistenceProvider.storeBoolean(key, isDefined(key));
		}
		
		// Store the list of the keys that can be used to reconstruct
		// this object as a comma-separated list
		persistenceProvider.storeString(KEYS_KEY + getStorableName(), sb.toString());
	}

	/**
	 * Undefine the specified identifier.
	 * 
	 * @param identifier
	 */
	public void undefine(String identifier) {
		map.put(identifier, Boolean.FALSE);
	}
	
	/**
	 * Return the name which may be used for storage.
	 * 
	 * @return
	 */
	String getStorableName() {
		return name.replaceAll("\\ ", "_");
	}
	
	/**
	 * Safely test equality of the two objects.
	 * 
	 * @param object1
	 * @param object2
	 * @return
	 */
	private boolean safeEquals(Object object1, Object object2) {
		boolean equals = false;
		
		if ((object1 == null) && (object2 == null)) {
			equals = true;
		} else if ((object1 != null) && (object2 != null)) {
			equals = object1.equals(object2);
		}
		
		return equals;
	}
	
	/**
	 * Safely gather the hashcode of the specified object.
	 * 
	 * @param object
	 * @return
	 */
	private int safeHash(Object object) {
		return (object != null) ? object.hashCode() : 0;
	}
}