edu.stanford.nlp.util.TwoDimensionalMap Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of stanford-parser Show documentation
Stanford Parser processes raw text in English, Chinese, German, Arabic, and French, and extracts constituency parse trees.
There is a newer version: 3.9.2
Show newest version
package edu.stanford.nlp.util;

import java.util.*;
import java.io.Serializable;
import java.util.function.Function;

import edu.stanford.nlp.util.MapFactory;

/**
 * @author grenager
 */
public class TwoDimensionalMap implements Serializable, Iterable> {

  private static final long serialVersionUID = 2L;
  private final MapFactory> mf1;
  private final MapFactory mf2;
  Map> map;
  
  public int size() {
    int size = 0;
    for (Map.Entry> entry : map.entrySet()) {
      size += (entry.getValue().size());
    }
    return size;
  }

  public boolean isEmpty() {
    for (Map.Entry> entry : map.entrySet()) {
      if (!entry.getValue().isEmpty()) {
        return false;
      }
    }
    return true;
  }

  public V put(K1 key1, K2 key2, V value) {
    Map m = getMap(key1);
    return m.put(key2, value);
  }

  // adds empty hashmap for key key1
  public void put(K1 key1) {
    map.put(key1, mf2.newMap());
  }

  public boolean contains(K1 key1, K2 key2) {
    if (!containsKey(key1)) {
      return false;
    }
    return getMap(key1).containsKey(key2);
  }

  public V get(K1 key1, K2 key2) {
    Map m = getMap(key1);
    return m.get(key2);
  }

  public V remove(K1 key1, K2 key2) {
    return get(key1).remove(key2);
  }

  /**
   * Removes all of the data associated with the first key in the map
   */
  public void remove(K1 key1) {
    map.remove(key1);
  }

  public void clear() {
    map.clear();
  }

  public boolean containsKey(K1 key1) {
    return map.containsKey(key1);
  }

  public Map get(K1 key1) {
    return getMap(key1);
  }

  public Map getMap(K1 key1) {
    Map m = map.get(key1);
    if (m == null) {
      m = mf2.newMap();
      map.put(key1, m);
    }
    return m;
  }

  public Collection values() {
    // TODO: Should return a specialized class
    List s = Generics.newArrayList();
    for (Map innerMap : map.values()) {
      s.addAll(innerMap.values());
    }
    return s;
  }

  public Set firstKeySet() {
    return map.keySet();
  }

  public Set secondKeySet() {
    Set keys = Generics.newHashSet();
    for (K1 k1 : map.keySet()) {
      keys.addAll(get(k1).keySet());
    }
    return keys;
  }

  /**
   * Adds all of the entries in the other map, performing
   * function on them to transform the values
   */
  public  void addAll(TwoDimensionalMap other, Function function) {
    for (TwoDimensionalMap.Entry entry : other) {
      put(entry.getFirstKey(), entry.getSecondKey(), function.apply(entry.getValue()));
    }
  }

  public TwoDimensionalMap() {
    this(MapFactory.>hashMapFactory(), MapFactory.hashMapFactory());
  }

  public TwoDimensionalMap(TwoDimensionalMap tdm) {
    this(tdm.mf1, tdm.mf2);
    for (K1 k1 : tdm.map.keySet()) {
      Map m = tdm.map.get(k1);
      Map copy = mf2.newMap();
      copy.putAll(m);
      this.map.put(k1, copy);
    }
  }

  public TwoDimensionalMap(MapFactory> mf1, MapFactory mf2) {
    this.mf1 = mf1;
    this.mf2 = mf2;
    this.map = mf1.newMap();
  }

  public static  TwoDimensionalMap hashMap() {
    return new TwoDimensionalMap(MapFactory.>hashMapFactory(), MapFactory.hashMapFactory());
  }

  public static  TwoDimensionalMap treeMap() {
    return new TwoDimensionalMap(MapFactory.>treeMapFactory(), MapFactory.treeMapFactory());
  }

  public static  TwoDimensionalMap identityHashMap() {
    return new TwoDimensionalMap(MapFactory.>identityHashMapFactory(), MapFactory.identityHashMapFactory());
  }

  @Override
  public String toString() {
    return map.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (!(o instanceof TwoDimensionalMap)) {
      return false;
    }
    TwoDimensionalMap other = (TwoDimensionalMap) o;
    return map.equals(other.map);
  }

  @Override
  public int hashCode() {
    return map.hashCode();
  }

  /**
   * Iterate over the map using the iterator and entry inner classes.
   */
  public Iterator> iterator() {
    return new TwoDimensionalMapIterator(this);
  }

  public Iterator valueIterator() {
    return new TwoDimensionalMapValueIterator(this);
  }

  static class TwoDimensionalMapValueIterator implements Iterator {
    Iterator> entryIterator;

    TwoDimensionalMapValueIterator(TwoDimensionalMap map) {
      entryIterator = map.iterator();
    }

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

    public V next() {
      Entry next = entryIterator.next();
      return next.getValue();
    }

    public void remove() {
      entryIterator.remove();
    }
  }

  /**
   * This inner class represents a single entry in the TwoDimensionalMap.  
   * Iterating over the map will give you these.
   */
  public static class Entry {
    K1 firstKey;
    K2 secondKey;
    V value;

    Entry(K1 k1, K2 k2, V v) { 
      firstKey = k1;
      secondKey = k2;
      value = v;
    }

    public K1 getFirstKey() { return firstKey; }
    public K2 getSecondKey() { return secondKey; }
    public V getValue() { return value; }

    @Override
    public String toString() {
      return "(" + firstKey + "," + secondKey + "," + value + ")";
    }
  }

  /**
   * Internal class which represents an iterator over the data in the
   * TwoDimensionalMap.  It keeps state in the form of an iterator
   * over the outer map, which maps keys to inner maps, and an
   * iterator over the most recent inner map seen.  When the inner map
   * has been completely iterated over, the outer map iterator
   * advances one step.  The iterator is finished when all key pairs
   * have been returned once.
   */
  static class TwoDimensionalMapIterator implements Iterator> {
    Iterator>> outerIterator;
    Iterator> innerIterator;
    Entry next;

    TwoDimensionalMapIterator(TwoDimensionalMap map) {
      outerIterator = map.map.entrySet().iterator();
      primeNext();
    }

    public boolean hasNext() {
      return next != null;
    }

    public Entry next() {
      if (next == null) {
        throw new NoSuchElementException();
      }
      Entry result = next;
      primeNext();
      return result;
    }

    private void primeNext() {
      K1 k1 = null;
      if (next != null) {
        k1 = next.getFirstKey();
      }
      while (innerIterator == null || !innerIterator.hasNext()) {
        if (!outerIterator.hasNext()) {
          next = null;
          return;
        }
        Map.Entry> outerEntry = outerIterator.next();
        k1 = outerEntry.getKey();
        innerIterator = outerEntry.getValue().entrySet().iterator();
      }
      Map.Entry innerEntry = innerIterator.next();
      next = new Entry(k1, innerEntry.getKey(), innerEntry.getValue());
    }

    public void remove() {
      throw new UnsupportedOperationException();
    }
  }
}