package aimax.osm.data;
import java.util.HashSet;
import java.util.Hashtable;
import aimax.osm.data.entities.EntityAttribute;
/**
* Singleton, maintaining entity attributes. This manager maintains
* a hash table for attribute key and value strings, a second for
* attributes consisting of two such strings, and additionally some filters
* for attributes to be ignored. This manager tries to reduce storage
* consumption by storing just one representation for each string.
* @author Ruediger Lunde
*/
public class EntityAttributeManager {
private static EntityAttributeManager instance;
Hashtable<String, String> internedTexts;
Hashtable<EntityAttribute, EntityAttribute> internedAttributes;
HashSet<String> ignoredAttKeys;
boolean ignorePathKeys;
/** Private constructor. */
private EntityAttributeManager() {
internedTexts = new Hashtable<String, String>();
internedAttributes = new Hashtable<EntityAttribute, EntityAttribute>();
ignoredAttKeys = new HashSet<String>();
}
/** Returns the singleton instance. */
public static EntityAttributeManager instance() {
if (instance == null) {
instance = new EntityAttributeManager();
}
return instance;
}
/** Clears all hash tables. */
public void clearHash() {
internedTexts.clear();
internedAttributes.clear();
}
/** Clears the attribute key filters. */
public void clearFilter() {
ignoredAttKeys.clear();
ignorePathKeys = false;
}
/** Advises the manager to ignore attributes with certain keys. */
public void ignoreAttKeys(String[] attKeys, boolean ignorePathKeys) {
ignoredAttKeys.clear();
for (String key : attKeys)
ignoredAttKeys.add(key);
this.ignorePathKeys = ignorePathKeys;
}
/**
* Checks whether <code>att</code> has to be ignored with respect to
* the attribute filter in use. Otherwise <code>att</code> is added to
* the internal hash tables and the interned version of it is returned.
*/
public EntityAttribute intern(EntityAttribute att) {
EntityAttribute result = null;
// this version seems to have no measurable advantage:
// result = internedAttributes.get(att);
// if (result == null && !ignoredAttNames.contains(att.getName())
// && (!ignorePathNames || !att.getName().contains(":"))) {
// result = new EntityAttribute
// (intern(att.getName()), intern(att.getValue()));
// internedAttributes.put(result, result);
// }
// return result;
if (!ignoredAttKeys.contains(att.getKey())
&& (!ignorePathKeys || !att.getKey().contains(":"))) {
att.setKey(intern(att.getKey()));
att.setValue(intern(att.getValue()));
result = att;
}
return result;
}
/** Gets a unified representation of <code>text</code>. */
private String intern(String text) {
String result = internedTexts.get(text);
if (result == null) {
internedTexts.put(text, text);
result = text;
}
return text;
}
}