com.google.common.primitives.Primitives Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
The newest version!
/*
* Copyright (C) 2007 The Guava 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 com.google.common.primitives;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.GwtCompatible;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* Contains static utility methods pertaining to primitive types and their corresponding wrapper
* types.
*
* @author Kevin Bourrillion
* @since 1.0
*/
@GwtCompatible
@ElementTypesAreNonnullByDefault
public final class Primitives {
private Primitives() {}
/** A map from primitive types to their corresponding wrapper types. */
private static final Map, Class> PRIMITIVE_TO_WRAPPER_TYPE;
/** A map from wrapper types to their corresponding primitive types. */
private static final Map, Class> WRAPPER_TO_PRIMITIVE_TYPE;
// Sad that we can't use a BiMap. :(
static {
Map, Class> primToWrap = new LinkedHashMap<>(16);
Map, Class> wrapToPrim = new LinkedHashMap<>(16);
add(primToWrap, wrapToPrim, boolean.class, Boolean.class);
add(primToWrap, wrapToPrim, byte.class, Byte.class);
add(primToWrap, wrapToPrim, char.class, Character.class);
add(primToWrap, wrapToPrim, double.class, Double.class);
add(primToWrap, wrapToPrim, float.class, Float.class);
add(primToWrap, wrapToPrim, int.class, Integer.class);
add(primToWrap, wrapToPrim, long.class, Long.class);
add(primToWrap, wrapToPrim, short.class, Short.class);
add(primToWrap, wrapToPrim, void.class, Void.class);
PRIMITIVE_TO_WRAPPER_TYPE = Collections.unmodifiableMap(primToWrap);
WRAPPER_TO_PRIMITIVE_TYPE = Collections.unmodifiableMap(wrapToPrim);
}
private static void add(
Map, Class> forward,
Map, Class> backward,
Class key,
Class value) {
forward.put(key, value);
backward.put(value, key);
}
/**
* Returns an immutable set of all nine primitive types (including {@code void}). Note that a
* simpler way to test whether a {@code Class} instance is a member of this set is to call {@link
* Class#isPrimitive}.
*
* @since 3.0
*/
public static Set> allPrimitiveTypes() {
return PRIMITIVE_TO_WRAPPER_TYPE.keySet();
}
/**
* Returns an immutable set of all nine primitive-wrapper types (including {@link Void}).
*
* @since 3.0
*/
public static Set> allWrapperTypes() {
return WRAPPER_TO_PRIMITIVE_TYPE.keySet();
}
/**
* Returns {@code true} if {@code type} is one of the nine primitive-wrapper types, such as {@link
* Integer}.
*
* @see Class#isPrimitive
*/
public static boolean isWrapperType(Class type) {
return WRAPPER_TO_PRIMITIVE_TYPE.containsKey(checkNotNull(type));
}
/**
* Returns the corresponding wrapper type of {@code type} if it is a primitive type; otherwise
* returns {@code type} itself. Idempotent.
*
*
* wrap(int.class) == Integer.class
* wrap(Integer.class) == Integer.class
* wrap(String.class) == String.class
*
*/
public static Class wrap(Class type) {
checkNotNull(type);
// cast is safe: long.class and Long.class are both of type Class
@SuppressWarnings("unchecked")
Class wrapped = (Class) PRIMITIVE_TO_WRAPPER_TYPE.get(type);
return (wrapped == null) ? type : wrapped;
}
/**
* Returns the corresponding primitive type of {@code type} if it is a wrapper type; otherwise
* returns {@code type} itself. Idempotent.
*
*
* unwrap(Integer.class) == int.class
* unwrap(int.class) == int.class
* unwrap(String.class) == String.class
*
*/
public static Class unwrap(Class type) {
checkNotNull(type);
// cast is safe: long.class and Long.class are both of type Class
@SuppressWarnings("unchecked")
Class unwrapped = (Class) WRAPPER_TO_PRIMITIVE_TYPE.get(type);
return (unwrapped == null) ? type : unwrapped;
}
}