001// Copyright 2006, 2007, 2012 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 015package org.apache.tapestry5.ioc.internal.util; 016 017import org.apache.tapestry5.ioc.util.CaseInsensitiveMap; 018import org.apache.tapestry5.ioc.util.Stack; 019 020import java.util.*; 021import java.util.concurrent.ConcurrentHashMap; 022import java.util.concurrent.ConcurrentMap; 023import 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<Foo, Bar> map = newMap(); 031 * </pre> 032 * <p/> 033 * <p/> 034 * This is a replacement for: 035 * <p/> 036 * <pre> 037 * Map<Foo, Bar> map = new HashMap<Foo, Bar>(); 038 * </pre> 039 */ 040public 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 * Contructs and returns a new generic {@link java.util.ArrayList} instance. 090 */ 091 public static <T> List<T> newList() 092 { 093 return new ArrayList<T>(); 094 } 095 096 /** 097 * Creates a new, fully modifiable list from an initial set of elements. 098 */ 099 public static <T, V extends T> List<T> newList(V... elements) 100 { 101 // Was call to newList(), but Sun JDK can't handle that. 102 return new ArrayList<T>(Arrays.asList(elements)); 103 } 104 105 /** 106 * Useful for queues. 107 */ 108 public static <T> LinkedList<T> newLinkedList() 109 { 110 return new LinkedList<T>(); 111 } 112 113 /** 114 * Constructs and returns a new {@link java.util.ArrayList} as a copy of the provided collection. 115 */ 116 public static <T, V extends T> List<T> newList(Collection<V> list) 117 { 118 return new ArrayList<T>(list); 119 } 120 121 /** 122 * Constructs and returns a new {@link java.util.concurrent.CopyOnWriteArrayList}. 123 */ 124 public static <T> List<T> newThreadSafeList() 125 { 126 return new CopyOnWriteArrayList<T>(); 127 } 128 129 public static <T> Stack<T> newStack() 130 { 131 return new Stack<T>(); 132 } 133 134 public static <V> Map<String, V> newCaseInsensitiveMap() 135 { 136 return new CaseInsensitiveMap<V>(); 137 } 138 139}