public DirtyFlagMap() 
{
    /*
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     * 
     * Constructors.
     * 
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     */
        map = new HashMap();
}

Create a DirtyFlagMap that 'wraps' a HashMap.

Also see:

java.util.HashMap

 public DirtyFlagMap(int initialCapacity) 
{
        map = new HashMap(initialCapacity);
}

Create a DirtyFlagMap that 'wraps' a HashMap that has the given initial capacity.

Also see:

java.util.HashMap

 public DirtyFlagMap(int initialCapacity,
    float loadFactor) 
{
        map = new HashMap(initialCapacity, loadFactor);
}

Create a DirtyFlagMap that 'wraps' a HashMap that has the given initial capacity and load factor.

Also see:

java.util.HashMap

 public  void clear() 
{
        if (map.isEmpty() == false) {
            dirty = true;
        }
        map.clear();
}

 public  void clearDirtyFlag() 
{
        dirty = false;
}

Clear the 'dirty' flag (set dirty flag to false).

 public Object clone() 
{
        DirtyFlagMap copy;
        try {
            copy = (DirtyFlagMap) super.clone();
            if (map instanceof HashMap) {
                copy.map = (Map)((HashMap)map).clone();
            }
        } catch (CloneNotSupportedException ex) {
            throw new IncompatibleClassChangeError("Not Cloneable.");
        }
        return copy;
}

 public boolean containsKey(Object key) 
{
        return map.containsKey(key);
}

 public boolean containsValue(Object val) 
{
        return map.containsValue(val);
}

 public Set entrySet() 
{
        return new DirtyFlagMapEntrySet(map.entrySet());
}

 public boolean equals(Object obj) 
{
        if (obj == null || !(obj instanceof DirtyFlagMap)) {
            return false;
        }
        return map.equals(((DirtyFlagMap) obj).getWrappedMap());
}

 public Object get(Object key) 
{
        return map.get(key);
}

 public Map getWrappedMap() 
{
        return map;
}

Get a direct handle to the underlying Map.

 public boolean isDirty() 
{
        return dirty;
}

Determine whether the Map is flagged dirty.

 public boolean isEmpty() 
{
        return map.isEmpty();
}

 public Set keySet() 
{
        return new DirtyFlagSet(map.keySet());
}

 public Object put(Object key,
    Object val) 
{
        dirty = true;
        return map.put(key, val);
}

 public  void putAll(Map t) 
{
        if (!t.isEmpty()) {
            dirty = true;
        }
        map.putAll(t);
}

 public Object remove(Object key) 
{
        Object obj = map.remove(key);
        if (obj != null) {
            dirty = true;
        }
        return obj;
}

 public int size() 
{
        return map.size();
}

 public Collection values() 
{
        return new DirtyFlagCollection(map.values());
}