| /* |
| * Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Sun designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Sun in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| * CA 95054 USA or visit www.sun.com if you need additional information or |
| * have any questions. |
| */ |
| |
| package com.sun.jmx.mbeanserver; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.IdentityHashMap; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.SortedMap; |
| import java.util.TreeMap; |
| import java.util.WeakHashMap; |
| import javax.management.MalformedObjectNameException; |
| import javax.management.ObjectName; |
| |
| public class Util { |
| static <K, V> Map<K, V> newMap() { |
| return new HashMap<K, V>(); |
| } |
| |
| static <K, V> Map<K, V> newSynchronizedMap() { |
| return Collections.synchronizedMap(Util.<K, V>newMap()); |
| } |
| |
| static <K, V> IdentityHashMap<K, V> newIdentityHashMap() { |
| return new IdentityHashMap<K, V>(); |
| } |
| |
| static <K, V> Map<K, V> newSynchronizedIdentityHashMap() { |
| Map<K, V> map = newIdentityHashMap(); |
| return Collections.synchronizedMap(map); |
| } |
| |
| static <K, V> SortedMap<K, V> newSortedMap() { |
| return new TreeMap<K, V>(); |
| } |
| |
| static <K, V> SortedMap<K, V> newSortedMap(Comparator<? super K> comp) { |
| return new TreeMap<K, V>(comp); |
| } |
| |
| static <K, V> Map<K, V> newInsertionOrderMap() { |
| return new LinkedHashMap<K, V>(); |
| } |
| |
| static <K, V> WeakHashMap<K, V> newWeakHashMap() { |
| return new WeakHashMap<K, V>(); |
| } |
| |
| static <E> Set<E> newSet() { |
| return new HashSet<E>(); |
| } |
| |
| static <E> Set<E> newSet(Collection<E> c) { |
| return new HashSet<E>(c); |
| } |
| |
| static <E> List<E> newList() { |
| return new ArrayList<E>(); |
| } |
| |
| static <E> List<E> newList(Collection<E> c) { |
| return new ArrayList<E>(c); |
| } |
| |
| public static ObjectName newObjectName(String s) { |
| try { |
| return new ObjectName(s); |
| } catch (MalformedObjectNameException e) { |
| throw new IllegalArgumentException(e); |
| } |
| } |
| |
| /* This method can be used by code that is deliberately violating the |
| * allowed checked casts. Rather than marking the whole method containing |
| * the code with @SuppressWarnings, you can use a call to this method for |
| * the exact place where you need to escape the constraints. Typically |
| * you will "import static" this method and then write either |
| * X x = cast(y); |
| * or, if that doesn't work (e.g. X is a type variable) |
| * Util.<X>cast(y); |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> T cast(Object x) { |
| return (T) x; |
| } |
| } |