org.infinispan.commons.util.CollectionFactory Maven / Gradle / Ivy

Go to download
package org.infinispan.commons.util;

import org.infinispan.commons.equivalence.AnyEquivalence;
import org.infinispan.commons.equivalence.Equivalence;
import org.infinispan.commons.equivalence.EquivalentHashMap;
import org.infinispan.commons.equivalence.EquivalentHashSet;
import org.infinispan.commons.equivalence.EquivalentLinkedHashMap;
import org.infinispan.commons.util.concurrent.jdk8backported.BoundedEquivalentConcurrentHashMapV8;
import org.infinispan.commons.util.concurrent.jdk8backported.ConcurrentParallelHashMapV8;
import org.infinispan.commons.util.concurrent.jdk8backported.EquivalentConcurrentHashMapV8;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * A factory for ConcurrentMaps.
 *
 * @author Manik Surtani
 * @author Galder Zamarreño
 * @since 5.1
 */
public class CollectionFactory {
   
   public static  ConcurrentMap makeConcurrentMap() {
      return new ConcurrentHashMap();
   }

   public static  ConcurrentMap makeConcurrentMap(int initCapacity) {
      return new ConcurrentHashMap(initCapacity);
   }

   public static  ConcurrentMap makeConcurrentMap(int initCapacity, int concurrencyLevel) {
      return new ConcurrentHashMap(initCapacity, 0.75f, concurrencyLevel);
   }
   
   public static  ConcurrentMap makeConcurrentParallelMap(int initCapacity, int concurrencyLevel) {
      return new ConcurrentParallelHashMapV8(initCapacity, AnyEquivalence.getInstance(),
            AnyEquivalence.getInstance());
   }

   public static  ConcurrentMap makeConcurrentMap(int initCapacity, float loadFactor, int concurrencyLevel) {
      return new ConcurrentHashMap(initCapacity, loadFactor, concurrencyLevel);
   }

   public static  ConcurrentMap makeConcurrentMap(
         Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new EquivalentConcurrentHashMapV8(keyEq, valueEq);
      else
         return makeConcurrentMap();
   }

   public static  ConcurrentMap makeConcurrentMap(
         int initCapacity, Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new EquivalentConcurrentHashMapV8(initCapacity, keyEq, valueEq);
      else
         return makeConcurrentMap(initCapacity);
   }

   public static  ConcurrentMap makeConcurrentMap(
         int initCapacity, int concurrencyLevel, Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new EquivalentConcurrentHashMapV8(
               initCapacity, concurrencyLevel, keyEq, valueEq);
      else
         return makeConcurrentMap(initCapacity, concurrencyLevel);
   }
   
   public static  ConcurrentMap makeConcurrentParallelMap(
         int initCapacity, int concurrencyLevel, Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new ConcurrentParallelHashMapV8(
               initCapacity, concurrencyLevel, keyEq, valueEq);
      else
         return makeConcurrentParallelMap(initCapacity, concurrencyLevel);
   }

   public static  ConcurrentMap makeConcurrentMap(
         int initCapacity, float loadFactor, int concurrencyLevel,
         Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new EquivalentConcurrentHashMapV8(
               initCapacity, loadFactor, concurrencyLevel, keyEq, valueEq);
      else
         return makeConcurrentMap(initCapacity, loadFactor, concurrencyLevel);
   }

   public static  ConcurrentMap makeBoundedConcurrentMap(int maxSize) {
      return new BoundedEquivalentConcurrentHashMapV8(maxSize,
         AnyEquivalence.getInstance(), AnyEquivalence.getInstance());
   }

   public static  Map makeMap(
         Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new EquivalentHashMap(keyEq, valueEq);
      else
         return new HashMap();
   }

   public static  Map makeMap(
         int initialCapacity, Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new EquivalentHashMap(initialCapacity, keyEq, valueEq);
      else
         return new HashMap(initialCapacity);
   }

   public static  Map makeMap(
         Map entries, Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new EquivalentHashMap(entries, keyEq, valueEq);
      else
         return new HashMap(entries);
   }

   public static  Map makeLinkedMap(int initialCapacity,
         float loadFactor, EquivalentLinkedHashMap.IterationOrder iterationOrder,
         Equivalence keyEq, Equivalence valueEq) {
      if (requiresEquivalent(keyEq, valueEq))
         return new EquivalentLinkedHashMap(initialCapacity, loadFactor, iterationOrder, keyEq, valueEq);
      else
         return new LinkedHashMap(initialCapacity, loadFactor, iterationOrder.toJdkAccessOrder());
   }

   public static  Set makeSet(Equivalence entryEq) {
      if (requiresEquivalent(entryEq))
         return new EquivalentHashSet(entryEq);
      else
         return new HashSet();
   }

   public static  Set makeSet(int initialCapacity, Equivalence entryEq) {
      if (requiresEquivalent(entryEq))
         return new EquivalentHashSet(initialCapacity, entryEq);
      else
         return new HashSet(initialCapacity);
   }

   /**
    * Create a Set backed by the specified array.
    *
    * @param entries the array by which the list will be backed
    * @param  type of elements
    * @return a set view of the specified array
    */
   public static  Set makeSet(T... entries) {
      return new HashSet(Arrays.asList(entries));
   }

   private static  boolean requiresEquivalent(
         Equivalence keyEq, Equivalence valueEq) {
      AnyEquivalence