2.4/user/src/com/google/web/bindery/autobean/shared/impl/SplittableSimpleMap.java

/*
 * 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;
  }
}