org.lastaflute.di.util.tiger.LdiCollectionsUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lasta-di Show documentation
DI Container for LastaFlute, super forked from Seasar as Java8
The newest version!
/*
 * Copyright 2015-2024 the original author or authors.
 *
 * 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 org.lastaflute.di.util.tiger;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;
import java.util.WeakHashMap;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;

/**
 * @author modified by jflute (originated in Seasar)
 */
public abstract class LdiCollectionsUtil {

    protected LdiCollectionsUtil() {
    }

    /**
     * @param 
     * @param capacity
     * @return 
     * @see ArrayBlockingQueue#ArrayBlockingQueue(int)
     */
    public static  ArrayBlockingQueue newArrayBlockingQueue(final int capacity) {
        return new ArrayBlockingQueue(capacity);
    }

    /**
     * @param 
     * @param capacity
     * @param fair
     * @return 
     * @see ArrayBlockingQueue#ArrayBlockingQueue(int, boolean)
     */
    public static  ArrayBlockingQueue newArrayBlockingQueue(final int capacity, final boolean fair) {
        return new ArrayBlockingQueue(capacity, fair);
    }

    /**
     * @param 
     * @param capacity
     * @param fair
     * @param c
     * @return 
     * @see ArrayBlockingQueue#ArrayBlockingQueue(int, boolean, Collection)
     */
    public static  ArrayBlockingQueue newArrayBlockingQueue(final int capacity, final boolean fair, final Collection c) {
        return new ArrayBlockingQueue(capacity, fair, c);
    }

    /**
     * @param 
     * @return 
     * @see ArrayList#ArrayList()
     */
    public static  ArrayList newArrayList() {
        return new ArrayList();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see ArrayList#ArrayList(Collection)
     */
    public static  ArrayList newArrayList(final Collection c) {
        return new ArrayList(c);
    }

    /**
     * @param 
     * @param initialCapacity
     * @return 
     * @see ArrayList#ArrayList(int)
     */
    public static  ArrayList newArrayList(final int initialCapacity) {
        return new ArrayList(initialCapacity);
    }

    /**
     * @param 
     * @param 
     * @return 
     * @see ConcurrentHashMap#ConcurrentHashMap()
     */
    public static  ConcurrentHashMap newConcurrentHashMap() {
        return new ConcurrentHashMap();
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @return 
     * @see ConcurrentHashMap#ConcurrentHashMap(int)
     */
    public static  ConcurrentHashMap newConcurrentHashMap(final int initialCapacity) {
        return new ConcurrentHashMap(initialCapacity);
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @param loadFactor
     * @param concurrencyLevel
     * @return 
     * @see ConcurrentHashMap#ConcurrentHashMap(int, float, int)
     */
    public static  ConcurrentHashMap newConcurrentHashMap(final int initialCapacity, final float loadFactor,
            final int concurrencyLevel) {
        return new ConcurrentHashMap(initialCapacity, loadFactor, concurrencyLevel);
    }

    /**
     * @param 
     * @param 
     * @param m
     * @return 
     * @see ConcurrentHashMap#ConcurrentHashMap(Map)
     */
    public static  ConcurrentHashMap newConcurrentHashMap(final Map m) {
        return new ConcurrentHashMap(m);
    }

    /**
     * @param 
     * @return 
     * @see ConcurrentLinkedQueue#ConcurrentLinkedQueue()
     */
    public static  ConcurrentLinkedQueue newConcurrentLinkedQueue() {
        return new ConcurrentLinkedQueue();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see ConcurrentLinkedQueue#ConcurrentLinkedQueue(Collection)
     */
    public static  ConcurrentLinkedQueue newConcurrentLinkedQueue(final Collection c) {
        return new ConcurrentLinkedQueue(c);
    }

    /**
     * @param 
     * @return 
     * @see CopyOnWriteArrayList#CopyOnWriteArrayList()
     */
    public static  CopyOnWriteArrayList newCopyOnWriteArrayList() {
        return new CopyOnWriteArrayList();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see CopyOnWriteArrayList#CopyOnWriteArrayList(Collection)
     */
    public static  CopyOnWriteArrayList newCopyOnWriteArrayList(final Collection c) {
        return new CopyOnWriteArrayList(c);
    }

    /**
     * @param 
     * @param toCopyIn
     * @return 
     * @see CopyOnWriteArrayList#CopyOnWriteArrayList(Object[])
     */
    public static  CopyOnWriteArrayList newCopyOnWriteArrayList(final E[] toCopyIn) {
        return new CopyOnWriteArrayList(toCopyIn);
    }

    /**
     * @param 
     * @return 
     * @see CopyOnWriteArraySet#CopyOnWriteArraySet()
     */
    public static  CopyOnWriteArraySet newCopyOnWriteArraySet() {
        return new CopyOnWriteArraySet();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see CopyOnWriteArraySet#CopyOnWriteArraySet(Collection)
     */
    public static  CopyOnWriteArraySet newCopyOnWriteArraySet(final Collection c) {
        return new CopyOnWriteArraySet(c);
    }

    /**
     * @param 
     * @return 
     * @see DelayQueue#DelayQueue()
     */
    public static  DelayQueue newDelayQueue() {
        return new DelayQueue();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see DelayQueue#DelayQueue(Collection)
     */
    public static  DelayQueue newDelayQueue(final Collection c) {
        return new DelayQueue(c);
    }

    /**
     * @param 
     * @param 
     * @return 
     * @see HashMap#HashMap()
     */
    public static  HashMap newHashMap() {
        return new HashMap();
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @return 
     * @see HashMap#HashMap(int)
     */
    public static  HashMap newHashMap(final int initialCapacity) {
        return new HashMap(initialCapacity);
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @param loadFactor
     * @return 
     * @see HashMap#HashMap(int, float)
     */
    public static  HashMap newHashMap(final int initialCapacity, final float loadFactor) {
        return new HashMap(initialCapacity, loadFactor);
    }

    /**
     * @param 
     * @param 
     * @param m
     * @return 
     * @see HashMap#HashMap(int, float)
     */
    public static  HashMap newHashMap(final Map m) {
        return new HashMap(m);
    }

    /**
     * @param 
     * @return 
     * @see HashSet#HashSet()
     */
    public static  HashSet newHashSet() {
        return new HashSet();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see HashSet#HashSet()
     */
    public static  HashSet newHashSet(final Collection c) {
        return new HashSet(c);
    }

    /**
     * @param 
     * @param initialCapacity
     * @return 
     * @see HashSet#HashSet()
     */
    public static  HashSet newHashSet(final int initialCapacity) {
        return new HashSet(initialCapacity);
    }

    /**
     * @param 
     * @param initialCapacity
     * @param loadFactor
     * @return 
     * @see HashSet#HashSet()
     */
    public static  HashSet newHashSet(final int initialCapacity, final float loadFactor) {
        return new HashSet(initialCapacity, loadFactor);
    }

    /**
     * @param 
     * @param 
     * @return 
     * @see Hashtable#Hashtable()
     */
    public static  Hashtable newHashtable() {
        return new Hashtable();
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @return 
     * @see Hashtable#Hashtable(int)
     */
    public static  Hashtable newHashtable(final int initialCapacity) {
        return new Hashtable(initialCapacity);
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @param loadFactor
     * @return 
     * @see Hashtable#Hashtable(int, float)
     */
    public static  Hashtable newHashtable(final int initialCapacity, final float loadFactor) {
        return new Hashtable(initialCapacity, loadFactor);
    }

    /**
     * @param 
     * @param 
     * @param m
     * @return 
     * @see Hashtable#Hashtable(Map)
     */
    public static  Hashtable newHashtable(final Map m) {
        return new Hashtable(m);
    }

    /**
     * @param 
     * @param 
     * @return 
     * @see IdentityHashMap#IdentityHashMap()
     */
    public static  IdentityHashMap newIdentityHashMap() {
        return new IdentityHashMap();
    }

    /**
     * @param 
     * @param 
     * @param expectedMaxSize
     * @return 
     * @see IdentityHashMap#IdentityHashMap(int)
     */
    public static  IdentityHashMap newIdentityHashMap(final int expectedMaxSize) {
        return new IdentityHashMap(expectedMaxSize);
    }

    /**
     * @param 
     * @param 
     * @param m
     * @return 
     * @see IdentityHashMap#IdentityHashMap(Map)
     */
    public static  IdentityHashMap newIdentityHashMap(final Map m) {
        return new IdentityHashMap(m);
    }

    /**
     * @param 
     * @return 
     * @see LinkedBlockingQueue#LinkedBlockingQueue()
     */
    public static  LinkedBlockingQueue newLinkedBlockingQueue() {
        return new LinkedBlockingQueue();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see LinkedBlockingQueue#LinkedBlockingQueue(Collection)
     */
    public static  LinkedBlockingQueue newLinkedBlockingQueue(final Collection c) {
        return new LinkedBlockingQueue(c);
    }

    /**
     * @param 
     * @param initialCapacity
     * @return 
     * @see LinkedBlockingQueue#LinkedBlockingQueue(int)
     */
    public static  LinkedBlockingQueue newLinkedBlockingQueue(final int initialCapacity) {
        return new LinkedBlockingQueue(initialCapacity);
    }

    /**
     * @param 
     * @param 
     * @return 
     * @see LinkedHashMap#LinkedHashMap()
     */
    public static  LinkedHashMap newLinkedHashMap() {
        return new LinkedHashMap();
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @return 
     * @see LinkedHashMap#LinkedHashMap(int)
     */
    public static  LinkedHashMap newLinkedHashMap(final int initialCapacity) {
        return new LinkedHashMap(initialCapacity);
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @param loadFactor
     * @return 
     * @see LinkedHashMap#LinkedHashMap(int, float)
     */
    public static  LinkedHashMap newLinkedHashMap(final int initialCapacity, final float loadFactor) {
        return new LinkedHashMap(initialCapacity, loadFactor);
    }

    /**
     * @param 
     * @param 
     * @param m
     * @return 
     * @see LinkedHashMap#LinkedHashMap(Map)
     */
    public static  LinkedHashMap newLinkedHashMap(final Map m) {
        return new LinkedHashMap(m);
    }

    /**
     * @param 
     * @return 
     * @see LinkedHashSet#LinkedHashSet()
     */
    public static  LinkedHashSet newLinkedHashSet() {
        return new LinkedHashSet();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see LinkedHashSet#LinkedHashSet(Collection)
     */
    public static  LinkedHashSet newLinkedHashSet(final Collection c) {
        return new LinkedHashSet(c);
    }

    /**
     * @param 
     * @param initialCapacity
     * @return 
     * @see LinkedHashSet#LinkedHashSet(int)
     */
    public static  LinkedHashSet newLinkedHashSet(final int initialCapacity) {
        return new LinkedHashSet(initialCapacity);
    }

    /**
     * @param 
     * @param initialCapacity
     * @param loadFactor
     * @return 
     * @see LinkedHashSet#LinkedHashSet(int, float)
     */
    public static  LinkedHashSet newLinkedHashSet(final int initialCapacity, final float loadFactor) {
        return new LinkedHashSet(initialCapacity, loadFactor);
    }

    /**
     * @param 
     * @return 
     * @see LinkedList#LinkedList()
     */
    public static  LinkedList newLinkedList() {
        return new LinkedList();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see LinkedList#LinkedList(Collection)
     */
    public static  LinkedList newLinkedList(final Collection c) {
        return new LinkedList(c);
    }

    /**
     * @param 
     * @return 
     * @see PriorityBlockingQueue#PriorityBlockingQueue()
     */
    public static  PriorityBlockingQueue newPriorityBlockingQueue() {
        return new PriorityBlockingQueue();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see PriorityBlockingQueue#PriorityBlockingQueue(Collection)
     */
    public static  PriorityBlockingQueue newPriorityBlockingQueue(final Collection c) {
        return new PriorityBlockingQueue(c);
    }

    /**
     * @param 
     * @param initialCapacity
     * @return 
     * @see PriorityBlockingQueue#PriorityBlockingQueue(int)
     */
    public static  PriorityBlockingQueue newPriorityBlockingQueue(final int initialCapacity) {
        return new PriorityBlockingQueue(initialCapacity);
    }

    /**
     * @param 
     * @param initialCapacity
     * @param comparator
     * @return 
     * @see PriorityBlockingQueue#PriorityBlockingQueue(int, Comparator)
     */
    public static  PriorityBlockingQueue newPriorityBlockingQueue(final int initialCapacity, final Comparator comparator) {
        return new PriorityBlockingQueue(initialCapacity, comparator);
    }

    /**
     * @param 
     * @return 
     * @see PriorityQueue#PriorityQueue()
     */
    public static  PriorityQueue newPriorityQueue() {
        return new PriorityQueue();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see PriorityQueue#PriorityQueue(Collection)
     */
    public static  PriorityQueue newPriorityQueue(final Collection c) {
        return new PriorityQueue(c);
    }

    /**
     * @param 
     * @param initialCapacity
     * @return 
     * @see PriorityQueue#PriorityQueue(int)
     */
    public static  PriorityQueue newPriorityQueue(final int initialCapacity) {
        return new PriorityQueue(initialCapacity);
    }

    /**
     * @param 
     * @param initialCapacity
     * @param comparator
     * @return 
     * @see PriorityQueue#PriorityQueue(int, Comparator)
     */
    public static  PriorityQueue newPriorityQueue(final int initialCapacity, final Comparator comparator) {
        return new PriorityQueue(initialCapacity, comparator);
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see PriorityQueue#PriorityQueue(PriorityQueue)
     */
    public static  PriorityQueue newPriorityQueue(final PriorityQueue c) {
        return new PriorityQueue(c);
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see PriorityQueue#PriorityQueue(SortedSet)
     */
    public static  PriorityQueue newPriorityQueue(final SortedSet c) {
        return new PriorityQueue(c);
    }

    /**
     * @param 
     * @return 
     * @see Stack#Stack()
     */
    public static  Stack newStack() {
        return new Stack();
    }

    /**
     * @param 
     * @param 
     * @return 
     * @see TreeMap#TreeMap()
     */
    public static  TreeMap newTreeMap() {
        return new TreeMap();
    }

    /**
     * @param 
     * @param 
     * @param c
     * @return 
     * @see TreeMap#TreeMap()
     */
    public static  TreeMap newTreeMap(final Comparator c) {
        return new TreeMap(c);
    }

    /**
     * @param 
     * @param 
     * @param m
     * @return 
     * @see TreeMap#TreeMap(Map)
     */
    public static  TreeMap newTreeMap(final Map m) {
        return new TreeMap(m);
    }

    /**
     * @param 
     * @param 
     * @param m
     * @return 
     * @see TreeMap#TreeMap(SortedMap)
     */
    public static  TreeMap newTreeMap(final SortedMap m) {
        return new TreeMap(m);
    }

    /**
     * @param 
     * @return 
     * @see TreeSet#TreeSet()
     */
    public static  TreeSet newTreeSet() {
        return new TreeSet();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see TreeSet#TreeSet(Collection)
     */
    public static  TreeSet newTreeSet(final Collection c) {
        return new TreeSet(c);
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see TreeSet#TreeSet(Comparator)
     */
    public static  TreeSet newTreeSet(final Comparator c) {
        return new TreeSet(c);
    }

    /**
     * @param 
     * @param s
     * @return 
     * @see TreeSet#TreeSet(SortedSet)
     */
    public static  TreeSet newTreeSet(final SortedSet s) {
        return new TreeSet(s);
    }

    /**
     * @param 
     * @return 
     * @see Vector#Vector()
     */
    public static  Vector newVector() {
        return new Vector();
    }

    /**
     * @param 
     * @param c
     * @return 
     * @see Vector#Vector(Collection)
     */
    public static  Vector newVector(final Collection c) {
        return new Vector(c);
    }

    /**
     * @param 
     * @param initialCapacity
     * @return 
     * @see Vector#Vector(int)
     */
    public static  Vector newVector(final int initialCapacity) {
        return new Vector(initialCapacity);
    }

    /**
     * @param 
     * @param initialCapacity
     * @param capacityIncrement
     * @return 
     * @see Vector#Vector(int, int)
     */
    public static  Vector newVector(final int initialCapacity, final int capacityIncrement) {
        return new Vector(initialCapacity, capacityIncrement);
    }

    /**
     * @param 
     * @param 
     * @return 
     * @see WeakHashMap#WeakHashMap()
     */
    public static  WeakHashMap newWeakHashMap() {
        return new WeakHashMap();
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @return 
     * @see WeakHashMap#WeakHashMap(int)
     */
    public static  WeakHashMap newWeakHashMap(final int initialCapacity) {
        return new WeakHashMap(initialCapacity);
    }

    /**
     * @param 
     * @param 
     * @param initialCapacity
     * @param loadFactor
     * @return 
     * @see WeakHashMap#WeakHashMap(int, float)
     */
    public static  WeakHashMap newWeakHashMap(final int initialCapacity, final float loadFactor) {
        return new WeakHashMap(initialCapacity, loadFactor);
    }

    /**
     * @param 
     * @param 
     * @param m
     * @return 
     * @see WeakHashMap#WeakHashMap(Map)
     */
    public static  WeakHashMap newWeakHashMap(final Map m) {
        return new WeakHashMap(m);
    }

    /**
     * @param 
     * @param 
     * @param map
     * @param key
     * @param value
     * @return 
     * @see ConcurrentHashMap#putIfAbsent(Object, Object)
     */
    public static  V putIfAbsent(final ConcurrentMap map, final K key, final V value) {
        V exists = map.putIfAbsent(key, value);
        if (exists != null) {
            return exists;
        }
        return value;
    }

}