• Home
• edu.stanford.nlp
• stanford-parser
• 3.5.2
• source code
• MapFactory.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

package edu.stanford.nlp.util;

import java.io.Serializable;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * A factory class for vending different sorts of Maps.
 *
 * @author Dan Klein ([email protected])
 * @author Kayur Patel (kdpatel@cs)
 */
public abstract class MapFactory implements Serializable {

  // allow people to write subclasses
  protected MapFactory() {
  }

  private static final long serialVersionUID = 4529666940763477360L;

  @SuppressWarnings("unchecked")
  public static final MapFactory HASH_MAP_FACTORY = new HashMapFactory();

  @SuppressWarnings("unchecked")
  public static final MapFactory IDENTITY_HASH_MAP_FACTORY = new IdentityHashMapFactory();

  @SuppressWarnings("unchecked")
  private static final MapFactory WEAK_HASH_MAP_FACTORY = new WeakHashMapFactory();

  @SuppressWarnings("unchecked")
  private static final MapFactory TREE_MAP_FACTORY = new TreeMapFactory();

  @SuppressWarnings("unchecked")
  private static final MapFactory LINKED_HASH_MAP_FACTORY = new LinkedHashMapFactory();

  @SuppressWarnings("unchecked")
  private static final MapFactory ARRAY_MAP_FACTORY = new ArrayMapFactory();

  public static final MapFactory CONCURRENT_MAP_FACTORY = new ConcurrentMapFactory();

  /** Return a MapFactory that returns a HashMap.
   *  Implementation note: This method uses the same trick as the methods
   *  like emptyMap() introduced in the Collections class in JDK1.5 where
   *  callers can call this method with apparent type safety because this
   *  method takes the hit for the cast.
   *
   *  @return A MapFactory that makes a HashMap.
   */
  @SuppressWarnings("unchecked")
  public static  MapFactory hashMapFactory() {
    return HASH_MAP_FACTORY;
  }

  /** Return a MapFactory that returns an IdentityHashMap.
   *  Implementation note: This method uses the same trick as the methods
   *  like emptyMap() introduced in the Collections class in JDK1.5 where
   *  callers can call this method with apparent type safety because this
   *  method takes the hit for the cast.
   *
   *  @return A MapFactory that makes a HashMap.
   */
  @SuppressWarnings("unchecked")
  public static  MapFactory identityHashMapFactory() {
    return IDENTITY_HASH_MAP_FACTORY;
  }

  /** Return a MapFactory that returns a WeakHashMap.
   *  Implementation note: This method uses the same trick as the methods
   *  like emptyMap() introduced in the Collections class in JDK1.5 where
   *  callers can call this method with apparent type safety because this
   *  method takes the hit for the cast.
   *
   *  @return A MapFactory that makes a WeakHashMap.
   */
  @SuppressWarnings("unchecked")
  public static  MapFactory weakHashMapFactory() {
    return WEAK_HASH_MAP_FACTORY;
  }

  /** Return a MapFactory that returns a TreeMap.
   *  Implementation note: This method uses the same trick as the methods
   *  like emptyMap() introduced in the Collections class in JDK1.5 where
   *  callers can call this method with apparent type safety because this
   *  method takes the hit for the cast.
   *
   *  @return A MapFactory that makes an TreeMap.
   */
  @SuppressWarnings("unchecked")
  public static  MapFactory treeMapFactory() {
    return TREE_MAP_FACTORY;
  }

  /** 
   * Return a MapFactory that returns a TreeMap with the given Comparator.
   */
  public static  MapFactory treeMapFactory(Comparator comparator) {
    return new TreeMapFactory(comparator);
  }

  /** Return a MapFactory that returns an LinkedHashMap.
   *  Implementation note: This method uses the same trick as the methods
   *  like emptyMap() introduced in the Collections class in JDK1.5 where
   *  callers can call this method with apparent type safety because this
   *  method takes the hit for the cast.
   *
   *  @return A MapFactory that makes an LinkedHashMap.
   */
  @SuppressWarnings("unchecked")
  public static  MapFactory linkedHashMapFactory() {
    return LINKED_HASH_MAP_FACTORY;
  }

  /** Return a MapFactory that returns an ArrayMap.
   *  Implementation note: This method uses the same trick as the methods
   *  like emptyMap() introduced in the Collections class in JDK1.5 where
   *  callers can call this method with apparent type safety because this
   *  method takes the hit for the cast.
   *
   *  @return A MapFactory that makes an ArrayMap.
   */
  @SuppressWarnings("unchecked")
  public static  MapFactory arrayMapFactory() {
    return ARRAY_MAP_FACTORY;
  }



  private static class HashMapFactory extends MapFactory {

    private static final long serialVersionUID = -9222344631596580863L;

    @Override
    public Map newMap() {
      return Generics.newHashMap();
    }

    @Override
    public Map newMap(int initCapacity) {
      return Generics.newHashMap(initCapacity);
    }

    @Override
    public Set newSet() {
      return Generics.newHashSet();
    }

    @Override
    public Set newSet(Collection init) {
      return Generics.newHashSet(init);
    }

    @Override
    public  Map setMap(Map map) {
      map = Generics.newHashMap();
      return map;
    }

    @Override
    public  Map setMap(Map map, int initCapacity) {
      map = Generics.newHashMap(initCapacity);
      return map;
    }

  } // end class HashMapFactory


  private static class IdentityHashMapFactory extends MapFactory {

    private static final long serialVersionUID = -9222344631596580863L;

    @Override
    public Map newMap() {
      return new IdentityHashMap();
    }

    @Override
    public Map newMap(int initCapacity) {
      return new IdentityHashMap(initCapacity);
    }

    @Override
    public Set newSet() {
      return Collections.newSetFromMap(new IdentityHashMap());
    }

    @Override
    public Set newSet(Collection init) {
      Set set =  Collections.newSetFromMap(new IdentityHashMap<>());  // nothing more efficient to be done here...
      set.addAll(init);
      return set;
    }

    @Override
    public  Map setMap(Map map) {
      map = new IdentityHashMap();
      return map;
    }

    @Override
    public  Map setMap(Map map, int initCapacity) {
      map = new IdentityHashMap(initCapacity);
      return map;
    }

  } // end class IdentityHashMapFactory


  private static class WeakHashMapFactory extends MapFactory {

    private static final long serialVersionUID = 4790014244304941000L;

    @Override
    public Map newMap() {
      return new WeakHashMap();
    }

    @Override
    public Map newMap(int initCapacity) {
      return new WeakHashMap(initCapacity);
    }

    @Override
    public Set newSet() {
      return Collections.newSetFromMap(new WeakHashMap());
    }

    @Override
    public Set newSet(Collection init) {
      Set set = Collections.newSetFromMap(new WeakHashMap());
      set.addAll(init);
      return set;
    }


    @Override
    public  Map setMap(Map map) {
      map = new WeakHashMap();
      return map;
    }

    @Override
    public  Map setMap(Map map, int initCapacity) {
      map = new WeakHashMap(initCapacity);
      return map;
    }

  } // end class WeakHashMapFactory


  private static class TreeMapFactory extends MapFactory {

    private static final long serialVersionUID = -9138736068025818670L;

    private final Comparator comparator;

    public TreeMapFactory() {
      this.comparator = null;
    }

    public TreeMapFactory(Comparator comparator) {
      this.comparator = comparator;
    }

    @Override
    public Map newMap() {
      return comparator == null ? new TreeMap() : new TreeMap(comparator);
    }

    @Override
    public Map newMap(int initCapacity) {
      return newMap();
    }

    @Override
    public Set newSet() {
      return comparator == null ? new TreeSet() : new TreeSet(comparator);
    }

    @Override
    public Set newSet(Collection init) {
      return new TreeSet<>(init);
    }


    @Override
    public  Map setMap(Map map) {
      if (comparator == null) {
        throw new UnsupportedOperationException();
      }
      map = new TreeMap();
      return map;
    }

    @Override
    public  Map setMap(Map map, int initCapacity) {
      if (comparator == null) {
        throw new UnsupportedOperationException();
      }
      map = new TreeMap();
      return map;
    }

  } // end class TreeMapFactory

  private static class LinkedHashMapFactory extends MapFactory {

    private static final long serialVersionUID = -9138736068025818671L;

    @Override
    public Map newMap() {
      return new LinkedHashMap();
    }

    @Override
    public Map newMap(int initCapacity) {
      return newMap();
    }

    @Override
    public Set newSet() {
      return new LinkedHashSet();
    }

    @Override
    public Set newSet(Collection init) {
      return new LinkedHashSet<>(init);
    }


    @Override
    public  Map setMap(Map map) {
      map = new LinkedHashMap();
      return map;
    }

    @Override
    public  Map setMap(Map map, int initCapacity) {
      map = new LinkedHashMap();
      return map;
    }

  } // end class LinkedHashMapFactory


  private static class ArrayMapFactory extends MapFactory {

    private static final long serialVersionUID = -5855812734715185523L;

    @Override
    public Map newMap() {
      return new ArrayMap();
    }

    @Override
    public Map newMap(int initCapacity) {
      return new ArrayMap(initCapacity);
    }

    @Override
    public Set newSet() {
      return new ArraySet();
    }

    @Override
    public Set newSet(Collection init) {
      return new ArraySet();
    }

    @Override
    public  Map setMap(Map map) {
      return new ArrayMap();
    }

    @Override
    public  Map setMap(Map map, int initCapacity) {
      map = new ArrayMap(initCapacity);
      return map;
    }

  } // end class ArrayMapFactory


  private static class ConcurrentMapFactory extends MapFactory {

    private static final long serialVersionUID = -5855812734715185523L;

    @Override
    public Map newMap() {
      return new ConcurrentHashMap();
    }

    @Override
    public Map newMap(int initCapacity) {
      return new ConcurrentHashMap(initCapacity);
    }

    @Override
    public Set newSet() {
      return Collections.newSetFromMap(new ConcurrentHashMap());
    }

    @Override
    public Set newSet(Collection init) {
      Set set = Collections.newSetFromMap(new ConcurrentHashMap());
      set.addAll(init);
      return set;
    }

    @Override
    public  Map setMap(Map map) {
      return new ConcurrentHashMap();
    }

    @Override
    public  Map setMap(Map map, int initCapacity) {
      map = new ConcurrentHashMap(initCapacity);
      return map;
    }

  } // end class ConcurrentMapFactory

  /**
   * Returns a new non-parameterized map of a particular sort.
   *
   * @return A new non-parameterized map of a particular sort
   */
  public abstract Map newMap();

  /**
   * Returns a new non-parameterized map of a particular sort with an initial capacity.
   *
   * @param initCapacity initial capacity of the map
   * @return A new non-parameterized map of a particular sort with an initial capacity
   */
  public abstract Map newMap(int initCapacity);

  /**
   * A set with the same K parameterization of the Maps.
   */
  public abstract Set newSet();

  /**
   * A set with the same K parameterization, but initialized to the given collection.
   */
  public abstract Set newSet(Collection init);

  /**
   * A method to get a parameterized (genericized) map out.
   *
   * @param map A type-parameterized {@link Map} argument
   * @return A {@link Map} with type-parameterization identical to that of
   *         the argument.
   */
  public abstract  Map setMap(Map map);

  public abstract  Map setMap(Map map, int initCapacity);

}