/**
* Copyright (c) Rich Hickey. All rights reserved.
* The use and distribution terms for this software are covered by the
* Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
* which can be found in the file epl-v10.html at the root of this distribution.
* By using this software in any fashion, you are agreeing to be bound by
* the terms of this license.
* You must not remove this notice, or any other, from this software.
**/
package clojure.lang;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
/**
* Simple implementation of persistent map on an array
* <p/>
* Note that instances of this class are constant values
* i.e. add/remove etc return new values
* <p/>
* Copies array on every change, so only appropriate for _very_small_ maps
* <p/>
* null keys and values are ok, but you won't be able to distinguish a null value via valAt - use contains/entryAt
*/
public class PersistentArrayMap extends APersistentMap implements IEditableCollection {
final Object[] array;
static final int HASHTABLE_THRESHOLD = 16;
public static final PersistentArrayMap EMPTY = new PersistentArrayMap();
static public IPersistentMap create(Map other){
ITransientMap ret = EMPTY.asTransient();
for(Object o : other.entrySet())
{
Map.Entry e = (Entry) o;
ret = ret.assoc(e.getKey(), e.getValue());
}
return ret.persistent();
}
protected PersistentArrayMap(){
this.array = new Object[]{};
}
public PersistentArrayMap withMeta(IPersistentMap meta){
return new PersistentArrayMap(meta, array);
}
PersistentArrayMap create(Object... init){
return new PersistentArrayMap(meta(), init);
}
IPersistentMap createHT(Object[] init){
return PersistentHashMap.create(meta(), init);
}
/**
* This ctor captures/aliases the passed array, so do not modify later
*
* @param init {key1,val1,key2,val2,...}
*/
public PersistentArrayMap(Object[] init){
this.array = init;
}
public PersistentArrayMap(IPersistentMap meta, Object[] init){
super(meta);
this.array = init;
}
public int count(){
return array.length / 2;
}
public boolean containsKey(Object key){
return indexOf(key) >= 0;
}
public IMapEntry entryAt(Object key){
int i = indexOf(key);
if(i >= 0)
return new MapEntry(array[i],array[i+1]);
return null;
}
public IPersistentMap assocEx(Object key, Object val) throws Exception{
int i = indexOf(key);
Object[] newArray;
if(i >= 0)
{
throw new Exception("Key already present");
}
else //didn't have key, grow
{
if(array.length > HASHTABLE_THRESHOLD)
return createHT(array).assocEx(key, val);
newArray = new Object[array.length + 2];
if(array.length > 0)
System.arraycopy(array, 0, newArray, 2, array.length);
newArray[0] = key;
newArray[1] = val;
}
return create(newArray);
}
public IPersistentMap assoc(Object key, Object val){
int i = indexOf(key);
Object[] newArray;
if(i >= 0) //already have key, same-sized replacement
{
if(array[i + 1] == val) //no change, no op
return this;
newArray = array.clone();
newArray[i + 1] = val;
}
else //didn't have key, grow
{
if(array.length > HASHTABLE_THRESHOLD)
return createHT(array).assoc(key, val);
newArray = new Object[array.length + 2];
if(array.length > 0)
System.arraycopy(array, 0, newArray, 2, array.length);
newArray[0] = key;
newArray[1] = val;
}
return create(newArray);
}
public IPersistentMap without(Object key){
int i = indexOf(key);
if(i >= 0) //have key, will remove
{
int newlen = array.length - 2;
if(newlen == 0)
return empty();
Object[] newArray = new Object[newlen];
for(int s = 0, d = 0; s < array.length; s += 2)
{
if(!equalKey(array[s], key)) //skip removal key
{
newArray[d] = array[s];
newArray[d + 1] = array[s + 1];
d += 2;
}
}
return create(newArray);
}
//don't have key, no op
return this;
}
public IPersistentMap empty(){
return (IPersistentMap) EMPTY.withMeta(meta());
}
final public Object valAt(Object key, Object notFound){
int i = indexOf(key);
if(i >= 0)
return array[i + 1];
return notFound;
}
public Object valAt(Object key){
return valAt(key, null);
}
public int capacity(){
return count();
}
private int indexOf(Object key){
for(int i = 0; i < array.length; i += 2)
{
if(equalKey(array[i], key))
return i;
}
return -1;
}
static boolean equalKey(Object k1, Object k2){
if(k1 == null)
return k2 == null;
return k1.equals(k2);
}
public Iterator iterator(){
return new Iter(array);
}
public ISeq seq(){
if(array.length > 0)
return new Seq(array, 0);
return null;
}
static class Seq extends ASeq implements Counted{
final Object[] array;
final int i;
Seq(Object[] array, int i){
this.array = array;
this.i = i;
}
public Seq(IPersistentMap meta, Object[] array, int i){
super(meta);
this.array = array;
this.i = i;
}
public Object first(){
return new MapEntry(array[i],array[i+1]);
}
public ISeq next(){
if(i + 2 < array.length)
return new Seq(array, i + 2);
return null;
}
public int count(){
return (array.length - i) / 2;
}
public Obj withMeta(IPersistentMap meta){
return new Seq(meta, array, i);
}
}
static class Iter implements Iterator{
Object[] array;
int i;
//for iterator
Iter(Object[] array){
this(array, -2);
}
//for entryAt
Iter(Object[] array, int i){
this.array = array;
this.i = i;
}
public boolean hasNext(){
return i < array.length - 2;
}
public Object next(){
i += 2;
return new MapEntry(array[i],array[i+1]);
}
public void remove(){
throw new UnsupportedOperationException();
}
}
public ITransientMap asTransient(){
return new TransientArrayMap(array);
}
static final class TransientArrayMap extends ATransientMap {
int len;
final Object[] array;
Thread owner;
public TransientArrayMap(Object[] array){
this.owner = Thread.currentThread();
this.array = new Object[Math.max(HASHTABLE_THRESHOLD, array.length)];
System.arraycopy(array, 0, this.array, 0, array.length);
this.len = array.length;
}
private int indexOf(Object key){
for(int i = 0; i < len; i += 2)
{
if(equalKey(array[i], key))
return i;
}
return -1;
}
ITransientMap doAssoc(Object key, Object val){
int i = indexOf(key);
if(i >= 0) //already have key,
{
if(array[i + 1] != val) //no change, no op
array[i + 1] = val;
}
else //didn't have key, grow
{
if(len >= array.length)
return PersistentHashMap.create(array).asTransient().assoc(key, val);
array[len++] = key;
array[len++] = val;
}
return this;
}
ITransientMap doWithout(Object key) {
int i = indexOf(key);
if(i >= 0) //have key, will remove
{
if (len >= 2)
{
array[i] = array[len - 2];
array[i + 1] = array[len - 1];
}
len -= 2;
}
return this;
}
Object doValAt(Object key, Object notFound) {
int i = indexOf(key);
if (i >= 0)
return array[i + 1];
return notFound;
}
int doCount() {
return len / 2;
}
IPersistentMap doPersistent(){
ensureEditable();
owner = null;
Object[] a = new Object[len];
System.arraycopy(array,0,a,0,len);
return new PersistentArrayMap(a);
}
void ensureEditable(){
if(owner == Thread.currentThread())
return;
if(owner != null)
throw new IllegalAccessError("Transient used by non-owner thread");
throw new IllegalAccessError("Transient used after persistent! call");
}
}
}