/*
* Copyright 2011 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.web.bindery.autobean.shared.impl;
import com.google.web.bindery.autobean.shared.Splittable;
import com.google.web.bindery.autobean.shared.impl.AutoBeanCodexImpl.Coder;
import com.google.web.bindery.autobean.shared.impl.AutoBeanCodexImpl.EncodeState;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* A Map implementation for regular JSON maps with value-type keys.
*
* @param <K> the key type
* @param <V> the value type
*/
public class SplittableSimpleMap<K, V> implements Map<K, V>, HasSplittable {
private final Splittable data;
private final Coder keyCoder;
private final EncodeState state;
private final Coder valueCoder;
/**
* Don't hang the reified data from {@link #data} since we can't tell the
* __reified field from the actual data.
*/
private Splittable reified = StringQuoter.createSplittable();
public SplittableSimpleMap(Splittable data, Coder keyCoder, Coder valueCoder, EncodeState state) {
this.data = data;
this.keyCoder = keyCoder;
this.state = state;
this.valueCoder = valueCoder;
}
public void clear() {
for (String key : data.getPropertyKeys()) {
Splittable.NULL.assign(data, key);
reified.setReified(key, null);
}
}
public boolean containsKey(Object key) {
String encodedKey = encodedKey(key);
return !data.isUndefined(encodedKey) || reified.isReified(encodedKey);
}
public boolean containsValue(Object value) {
return values().contains(value);
}
public Set<java.util.Map.Entry<K, V>> entrySet() {
return new AbstractSet<Map.Entry<K, V>>() {
final List<String> keys = data.getPropertyKeys();
@Override
public Iterator<java.util.Map.Entry<K, V>> iterator() {
return new Iterator<Map.Entry<K, V>>() {
Iterator<String> keyIterator = keys.iterator();
String encodedKey;
public boolean hasNext() {
return keyIterator.hasNext();
}
public java.util.Map.Entry<K, V> next() {
encodedKey = keyIterator.next();
return new Map.Entry<K, V>() {
@SuppressWarnings("unchecked")
final K key = (K) keyCoder.decode(state, StringQuoter.split(StringQuoter
.quote(encodedKey)));
@SuppressWarnings("unchecked")
final V value = (V) valueCoder.decode(state, data.get(encodedKey));
public K getKey() {
return key;
}
public V getValue() {
return value;
}
public V setValue(V newValue) {
return put(key, newValue);
}
};
}
public void remove() {
Splittable.NULL.assign(data, encodedKey);
reified.setReified(encodedKey, null);
}
};
}
@Override
public int size() {
return keys.size();
}
};
}
public V get(Object key) {
String encodedKey = encodedKey(key);
return getRaw(encodedKey);
}
public Splittable getSplittable() {
return data;
}
public boolean isEmpty() {
return data.getPropertyKeys().isEmpty();
}
public Set<K> keySet() {
return new AbstractSet<K>() {
final List<String> keys = data.getPropertyKeys();
@Override
public Iterator<K> iterator() {
return new Iterator<K>() {
final Iterator<String> it = keys.iterator();
String lastEncodedKey;
public boolean hasNext() {
return it.hasNext();
}
public K next() {
lastEncodedKey = it.next();
@SuppressWarnings("unchecked")
K toReturn =
(K) keyCoder.decode(state, StringQuoter.split(StringQuoter.quote(lastEncodedKey)));
return toReturn;
}
public void remove() {
Splittable.NULL.assign(data, lastEncodedKey);
reified.setReified(lastEncodedKey, null);
}
};
}
@Override
public int size() {
return keys.size();
}
};
}
public V put(K key, V value) {
V toReturn = get(key);
String encodedKey = encodedKey(key);
reified.setReified(encodedKey, value);
Splittable encodedValue = valueCoder.extractSplittable(state, value);
if (encodedValue == null) {
// External datastructure
reified.setReified(AbstractAutoBean.UNSPLITTABLE_VALUES_KEY, true);
} else {
encodedValue.assign(data, encodedKey);
}
return toReturn;
}
public void putAll(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
public V remove(Object key) {
V toReturn = get(key);
String encodedKey = encodedKey(key);
reified.setReified(encodedKey, null);
Splittable.NULL.assign(data, encodedKey);
return toReturn;
}
public int size() {
return data.getPropertyKeys().size();
}
public Collection<V> values() {
return new AbstractCollection<V>() {
final List<String> keys = data.getPropertyKeys();
@Override
public Iterator<V> iterator() {
return new Iterator<V>() {
final Iterator<String> it = keys.iterator();
String lastEncodedKey;
public boolean hasNext() {
return it.hasNext();
}
public V next() {
lastEncodedKey = it.next();
return getRaw(lastEncodedKey);
}
public void remove() {
Splittable.NULL.assign(data, lastEncodedKey);
reified.setReified(lastEncodedKey, null);
}
};
}
@Override
public int size() {
return keys.size();
}
};
}
private String encodedKey(Object key) {
return keyCoder.extractSplittable(state, key).asString();
}
private V getRaw(String encodedKey) {
if (reified.isReified(encodedKey)) {
@SuppressWarnings("unchecked")
V toReturn = (V) reified.getReified(encodedKey);
return toReturn;
}
// Both undefined or an explicit null should return null here
if (data.isNull(encodedKey)) {
return null;
}
Splittable value = data.get(encodedKey);
@SuppressWarnings("unchecked")
V toReturn = (V) valueCoder.decode(state, value);
reified.setReified(encodedKey, toReturn);
return toReturn;
}
}