001    // Copyright 2006, 2007 The Apache Software Foundation
002    //
003    // Licensed under the Apache License, Version 2.0 (the "License");
004    // you may not use this file except in compliance with the License.
005    // You may obtain a copy of the License at
006    //
007    //     http://www.apache.org/licenses/LICENSE-2.0
008    //
009    // Unless required by applicable law or agreed to in writing, software
010    // distributed under the License is distributed on an "AS IS" BASIS,
011    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012    // See the License for the specific language governing permissions and
013    // limitations under the License.
014    
015    package org.apache.tapestry5.ioc.internal.util;
016    
017    import org.apache.tapestry5.ioc.util.CaseInsensitiveMap;
018    import org.apache.tapestry5.ioc.util.Stack;
019    
020    import java.util.*;
021    import java.util.concurrent.ConcurrentHashMap;
022    import java.util.concurrent.ConcurrentMap;
023    import java.util.concurrent.CopyOnWriteArrayList;
024    
025    /**
026     * Static factory methods to ease the creation of new collection types (when using generics). Most of these method
027     * leverage the compiler's ability to match generic types by return value. Typical usage (with a static import):
028     * <p/>
029     * <pre>
030     * Map&lt;Foo, Bar&gt; map = newMap();
031     * </pre>
032     * <p/>
033     * <p/>
034     * This is a replacement for:
035     * <p/>
036     * <pre>
037     * Map&lt;Foo, Bar&gt; map = new HashMap&lt;Foo, Bar&gt;();
038     * </pre>
039     */
040    public final class CollectionFactory
041    {
042        /**
043         * Constructs and returns a generic {@link HashMap} instance.
044         */
045        public static <K, V> Map<K, V> newMap()
046        {
047            return new HashMap<K, V>();
048        }
049    
050        /**
051         * Constructs and returns a generic {@link java.util.HashSet} instance.
052         */
053        public static <T> Set<T> newSet()
054        {
055            return new HashSet<T>();
056        }
057    
058        /**
059         * Contructs a new {@link HashSet} and initializes it using the provided collection.
060         */
061        public static <T, V extends T> Set<T> newSet(Collection<V> values)
062        {
063            return new HashSet<T>(values);
064        }
065    
066        public static <T, V extends T> Set<T> newSet(V... values)
067        {
068            // Was a call to newSet(), but Sun JDK can't handle that. Fucking generics.
069            return new HashSet<T>(Arrays.asList(values));
070        }
071    
072        /**
073         * Constructs a new {@link java.util.HashMap} instance by copying an existing Map instance.
074         */
075        public static <K, V> Map<K, V> newMap(Map<? extends K, ? extends V> map)
076        {
077            return new HashMap<K, V>(map);
078        }
079    
080        /**
081         * Constructs a new concurrent map, which is safe to access via multiple threads.
082         */
083        public static <K, V> ConcurrentMap<K, V> newConcurrentMap()
084        {
085            return new ConcurrentHashMap<K, V>();
086        }
087    
088        /**
089         * @since 5.3
090         */
091        public static <K, V> Map<K, V> newWeakHashMap()
092        {
093            return new WeakHashMap<K, V>();
094        }
095    
096        /**
097         * Contructs and returns a new generic {@link java.util.ArrayList} instance.
098         */
099        public static <T> List<T> newList()
100        {
101            return new ArrayList<T>();
102        }
103    
104        /**
105         * Creates a new, fully modifiable list from an initial set of elements.
106         */
107        public static <T, V extends T> List<T> newList(V... elements)
108        {
109            // Was call to newList(), but Sun JDK can't handle that.
110            return new ArrayList<T>(Arrays.asList(elements));
111        }
112    
113        /**
114         * Useful for queues.
115         */
116        public static <T> LinkedList<T> newLinkedList()
117        {
118            return new LinkedList<T>();
119        }
120    
121        /**
122         * Constructs and returns a new {@link java.util.ArrayList} as a copy of the provided collection.
123         */
124        public static <T, V extends T> List<T> newList(Collection<V> list)
125        {
126            return new ArrayList<T>(list);
127        }
128    
129        /**
130         * Constructs and returns a new {@link java.util.concurrent.CopyOnWriteArrayList}.
131         */
132        public static <T> List<T> newThreadSafeList()
133        {
134            return new CopyOnWriteArrayList<T>();
135        }
136    
137        public static <T> Stack<T> newStack()
138        {
139            return new Stack<T>();
140        }
141    
142        public static <T> Stack<T> newStack(int initialSize)
143        {
144            return new Stack<T>(initialSize);
145        }
146    
147        public static <V> Map<String, V> newCaseInsensitiveMap()
148        {
149            return new CaseInsensitiveMap<V>();
150        }
151    
152        public static <V> Map<String, V> newCaseInsensitiveMap(Map<String, ? extends V> map)
153        {
154            return new CaseInsensitiveMap<V>(map);
155        }
156    }