[CJ-dev] other-projects/marmalade/src/main/java/org/marmalade/util ScopedMapEntriesIterator.java,NONE,1.1 ScopedMap.java,NONE,1.1 ScopedMapEntry.java,NONE,1.1 ScopedMapEntriesSet.java,NONE,1.1

[John C. <joh...@co...>]

Update of /cvsroot/commonjava/other-projects/marmalade/src/main/java/org/marmalade/util
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30096/src/main/java/org/marmalade/util

Added Files:
	ScopedMapEntriesIterator.java ScopedMap.java 
	ScopedMapEntry.java ScopedMapEntriesSet.java 
Log Message:
initial checkin.

--- NEW FILE: ScopedMapEntriesSet.java ---
/* Created on Mar 25, 2004 */
package org.marmalade.util;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author jdcasey
 */
public class ScopedMapEntriesSet implements Set {
  
  private Map superMap;
  private Map thisMap;
  private Boolean extractKey;
  
  private List entries = new ArrayList();
  
  public ScopedMapEntriesSet(Map superMap, Map thisMap, Boolean extractKey) {
    this.superMap = superMap;
    this.thisMap = thisMap;
    this.extractKey = extractKey;
    update();
  }
  
  public Object extract(ScopedMapEntry entry){
    if(extractKey == null){
      return entry;
    }
    else if(Boolean.TRUE == extractKey){
      return entry.getKey();
    }
    else{
      return entry.getValue();
    }
  }

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

  public void clear() {
    thisMap.clear();
    for (Iterator it = entries.iterator(); it.hasNext();) {
      ScopedMapEntry entry = (ScopedMapEntry)it.next();
      if(entry.isMutable()){
        it.remove();
      }
    }
  }

  public boolean isEmpty() {
    return thisMap.isEmpty() && superMap.isEmpty();
  }

  public Object[] toArray() {
    Object[] objects = new Object[entries.size()];
    for (int i = 0; i < objects.length; i++) {
      objects[i] = extract((ScopedMapEntry)entries.get(i));
    }
    return objects;
  }

  public boolean add(Object o) {
    throw new UnsupportedOperationException("Add operation is not supported.");
  }

  public boolean contains(Object o) {
    for (Iterator it = entries.iterator(); it.hasNext();) {
      if(extract((ScopedMapEntry)it.next()).equals(o)){
        return true;
      }
    }
    return false;
  }

  public boolean remove(Object o) {
    for (Iterator it = entries.iterator(); it.hasNext();) {
      ScopedMapEntry entry = (ScopedMapEntry)it.next();
      if(extract(entry).equals(o)){
        if(entry.isMutable()){
          it.remove();
          thisMap.remove(entry.getKey());
          return true;
        }
        else{
          return false;
        }
      }
    }
    
    return false;
  }

  public boolean addAll(Collection c) {
    throw new UnsupportedOperationException("Add-all operation is not supported.");
  }

  public boolean containsAll(Collection c) {
    for (Iterator it = entries.iterator(); it.hasNext();) {
      if(!c.contains(extract((ScopedMapEntry)it.next()))){
        return false;
      }
    }
    return true;
  }

  public boolean removeAll(Collection c) {
    boolean changed = false;
    for (Iterator it = entries.iterator(); it.hasNext();) {
      ScopedMapEntry entry = (ScopedMapEntry)it.next();
      if(c.contains(extract(entry))){
        if(entry.isMutable()){
          it.remove();
          thisMap.remove(entry.getKey());
          changed = true;
        }
      }
    }
    
    return changed;
  }

  public boolean retainAll(Collection c) {
    boolean changed = false;
    for (Iterator it = entries.iterator(); it.hasNext();) {
      ScopedMapEntry entry = (ScopedMapEntry)it.next();
      if(!c.contains(extract(entry))){
        if(entry.isMutable()){
          it.remove();
          thisMap.remove(entry.getKey());
          changed = true;
        }
      }
    }
    
    return changed;
  }
  
  public Iterator iterator() {
    return new ScopedMapEntriesIterator(this, extractKey);
  }

  public Object[] toArray(Object[] a) {
    for (int i = 0; i < a.length; i++) {
      a[i] = entries.get(i);
    }
    
    if(entries.size() > a.length){
      throw new ArrayIndexOutOfBoundsException(a.length);
    }
    else{
      return a;
    }
  }

  Iterator entryIterator(){
    return entries.iterator();
  }
  
  void removeEntry(ScopedMapEntry entry){
    if(entry.isMutable()){
      entries.remove(entry);
      thisMap.remove(entry.getKey());
    }
  }
  
  void update(){
    for (Iterator it = superMap.entrySet().iterator(); it.hasNext();) {
      Map.Entry entry = (Map.Entry)it.next();
      Object key = entry.getKey();
      if(!thisMap.containsKey(key)){
        ScopedMapEntry sme = new ScopedMapEntry(entry, false);
        entries.add(sme);
      }
    }
    
    for (Iterator it = thisMap.entrySet().iterator(); it.hasNext();) {
      Map.Entry entry = (Map.Entry)it.next();
      ScopedMapEntry sme = new ScopedMapEntry(entry, true);
      entries.add(sme);
    }
  }

}

--- NEW FILE: ScopedMapEntry.java ---
/* Created on Mar 25, 2004 */
package org.marmalade.util;

import java.util.Map;
import java.util.Map.Entry;

/**
 * @author jdcasey
 */
public class ScopedMapEntry implements Entry {
  
  private Map.Entry entry;
  private boolean mutable = true;

  public ScopedMapEntry(Map.Entry entry, boolean mutable) {
    this.entry = entry;
    this.mutable = mutable;
  }
  
  public boolean isMutable(){
    return mutable;
  }

  public Object getKey() {
    return entry.getKey();
  }

  public Object getValue() {
    return entry.getValue();
  }

  public Object setValue(Object value) {
    if(!mutable){
      throw new UnsupportedOperationException("Specified map entry is immutable.");
    }
    else{
      return entry.setValue(value);
    }
  }

}

--- NEW FILE: ScopedMap.java ---
/* Created on Mar 25, 2004 */
package org.marmalade.util;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/** Create a local copy of all mappings in the super-map.
 * 
 * @author John Casey
 */
public class ScopedMap implements Map{
  
  private Map superMap;
  private Map thisMap;
  
  private int superMapSize;
  private ScopedMapEntriesSet keySet;
  private ScopedMapEntriesSet valueSet;
  private ScopedMapEntriesSet entrySet;
  
  public ScopedMap() {
    init(Collections.EMPTY_MAP);
  }
  
  public ScopedMap(Map superMap){
    init(superMap);
  }
  
  private void init(Map superMap){
    Map m = superMap;
    if(m == null){m = Collections.EMPTY_MAP;}
    this.superMap = Collections.unmodifiableMap(m);
    
    this.superMapSize = superMap.size();
    this.thisMap = new HashMap(superMap);
    
    this.entrySet = new ScopedMapEntriesSet(superMap, thisMap, null);
    this.keySet = new ScopedMapEntriesSet(superMap, thisMap, Boolean.TRUE);
    this.valueSet = new ScopedMapEntriesSet(superMap, thisMap, Boolean.FALSE);
  }
  
  private void update(){
    entrySet.update();
    keySet.update();
    valueSet.update();
  }
  
  public int size() {
    return superMapSize + thisMap.size();
  }

  public void clear() {
    thisMap.clear();
    update();
  }

  public boolean isEmpty() {
    return superMapSize < 1 || thisMap.isEmpty();
  }

  public boolean containsKey(Object key) {
    return thisMap.containsKey(key) || (superMap != null && superMap.containsKey(key));
  }

  public boolean containsValue(Object value) {
    return thisMap.containsValue(value) || (superMap != null && superMap.containsValue(value));
  }

  public Collection values() {
    return valueSet;
  }

  public void putAll(Map t) {
    thisMap.putAll(t);
    update();
  }

  public Set entrySet() {
    return entrySet;
  }

  public Set keySet() {
    return keySet;
  }

  public Object get(Object key) {
    Object result = thisMap.get(key);
    if(result == null){
      superMap.get(key);
    }
    
    return result;
  }

  public Object remove(Object key) {
    Object result = thisMap.remove(key);
    if(result != null){
      update();
    }
    return result;
  }

  public Object put(Object key, Object value) {
    Object result = thisMap.put(key, value);
    update();
    return result;
  }
  
}

--- NEW FILE: ScopedMapEntriesIterator.java ---
/* Created on Mar 25, 2004 */
package org.marmalade.util;

import java.util.Iterator;

/**
 * @author jdcasey
 */
public class ScopedMapEntriesIterator implements Iterator {
  
  private ScopedMapEntriesSet collection;
  private Iterator entryIterator;
  private Boolean extractKey;
  
  private ScopedMapEntry current;

  public ScopedMapEntriesIterator(ScopedMapEntriesSet collection, Boolean extractKey) {
    this.collection = collection;
    this.entryIterator = collection.entryIterator();
    this.extractKey = extractKey;
  }
  
  public Object extract(ScopedMapEntry entry){
    if(extractKey == null){
      return entry;
    }
    else if(Boolean.TRUE == extractKey){
      return entry.getKey();
    }
    else{
      return entry.getValue();
    }
  }

  public void remove() {
    if(current == null){
      throw new IllegalArgumentException("You must call next() before calling remove().");
    }
    else{
      collection.removeEntry(current);
    }
  }

  public boolean hasNext() {
    return entryIterator.hasNext();
  }

  public Object next() {
    current = (ScopedMapEntry)entryIterator.next();
    return extract(current);
  }

}