001/*
002 * Copyright (C) 2011 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. 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 distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.base;
016
017import static com.google.common.base.Preconditions.checkNotNull;
018
019import com.google.common.annotations.GwtCompatible;
020import com.google.common.annotations.GwtIncompatible;
021import java.io.Serializable;
022import java.lang.ref.WeakReference;
023import java.lang.reflect.Field;
024import java.util.EnumSet;
025import java.util.HashMap;
026import java.util.Map;
027import java.util.WeakHashMap;
028import javax.annotation.Nullable;
029
030/**
031 * Utility methods for working with {@link Enum} instances.
032 *
033 * @author Steve McKay
034 *
035 * @since 9.0
036 */
037@GwtCompatible(emulated = true)
038public final class Enums {
039
040  private Enums() {}
041
042  /**
043   * Returns the {@link Field} in which {@code enumValue} is defined. For example, to get the
044   * {@code Description} annotation on the {@code GOLF} constant of enum {@code Sport}, use
045   * {@code Enums.getField(Sport.GOLF).getAnnotation(Description.class)}.
046   *
047   * @since 12.0
048   */
049  @GwtIncompatible // reflection
050  public static Field getField(Enum<?> enumValue) {
051    Class<?> clazz = enumValue.getDeclaringClass();
052    try {
053      return clazz.getDeclaredField(enumValue.name());
054    } catch (NoSuchFieldException impossible) {
055      throw new AssertionError(impossible);
056    }
057  }
058
059  /**
060   * Returns an optional enum constant for the given type, using {@link Enum#valueOf}. If the
061   * constant does not exist, {@link Optional#absent} is returned. A common use case is for parsing
062   * user input or falling back to a default enum constant. For example,
063   * {@code Enums.getIfPresent(Country.class, countryInput).or(Country.DEFAULT);}
064   *
065   * @since 12.0
066   */
067  public static <T extends Enum<T>> Optional<T> getIfPresent(Class<T> enumClass, String value) {
068    checkNotNull(enumClass);
069    checkNotNull(value);
070    return Platform.getEnumIfPresent(enumClass, value);
071  }
072
073  @GwtIncompatible // java.lang.ref.WeakReference
074  private static final Map<Class<? extends Enum<?>>, Map<String, WeakReference<? extends Enum<?>>>>
075      enumConstantCache = new WeakHashMap<>();
076
077  @GwtIncompatible // java.lang.ref.WeakReference
078  private static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> populateCache(
079      Class<T> enumClass) {
080    Map<String, WeakReference<? extends Enum<?>>> result = new HashMap<>();
081    for (T enumInstance : EnumSet.allOf(enumClass)) {
082      result.put(enumInstance.name(), new WeakReference<Enum<?>>(enumInstance));
083    }
084    enumConstantCache.put(enumClass, result);
085    return result;
086  }
087
088  @GwtIncompatible // java.lang.ref.WeakReference
089  static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> getEnumConstants(
090      Class<T> enumClass) {
091    synchronized (enumConstantCache) {
092      Map<String, WeakReference<? extends Enum<?>>> constants = enumConstantCache.get(enumClass);
093      if (constants == null) {
094        constants = populateCache(enumClass);
095      }
096      return constants;
097    }
098  }
099
100  /**
101   * Returns a converter that converts between strings and {@code enum} values of type
102   * {@code enumClass} using {@link Enum#valueOf(Class, String)} and {@link Enum#name()}. The
103   * converter will throw an {@code IllegalArgumentException} if the argument is not the name of any
104   * enum constant in the specified enum.
105   *
106   * @since 16.0
107   */
108  public static <T extends Enum<T>> Converter<String, T> stringConverter(final Class<T> enumClass) {
109    return new StringConverter<T>(enumClass);
110  }
111
112  private static final class StringConverter<T extends Enum<T>> extends Converter<String, T>
113      implements Serializable {
114
115    private final Class<T> enumClass;
116
117    StringConverter(Class<T> enumClass) {
118      this.enumClass = checkNotNull(enumClass);
119    }
120
121    @Override
122    protected T doForward(String value) {
123      return Enum.valueOf(enumClass, value);
124    }
125
126    @Override
127    protected String doBackward(T enumValue) {
128      return enumValue.name();
129    }
130
131    @Override
132    public boolean equals(@Nullable Object object) {
133      if (object instanceof StringConverter) {
134        StringConverter<?> that = (StringConverter<?>) object;
135        return this.enumClass.equals(that.enumClass);
136      }
137      return false;
138    }
139
140    @Override
141    public int hashCode() {
142      return enumClass.hashCode();
143    }
144
145    @Override
146    public String toString() {
147      return "Enums.stringConverter(" + enumClass.getName() + ".class)";
148    }
149
150    private static final long serialVersionUID = 0L;
151  }
152}