Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 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.base;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 
 import  javax.annotation.Nullable;

Utility methods for working with Enum instances.

Author(s):
Steve McKay
Since:
9.0
 
 @GwtCompatible(emulated = true)
 public final class Enums {
 
   private Enums() {}

  
Returns the Field in which enumValue is defined. For example, to get the Description annotation on the GOLF constant of enum Sport, use Enums.getField(Sport.GOLF).getAnnotation(Description.class).

Since:
12.0
 
   @GwtIncompatible("reflection")
   public static Field getField(Enum<?> enumValue) {
     Class<?> clazz = enumValue.getDeclaringClass();
     try {
       return clazz.getDeclaredField(enumValue.name());
     } catch (NoSuchFieldException impossible) {
       throw new AssertionError(impossible);
     }
   }

  
Returns a Function that maps an Enum name to the associated Enum constant. The Function will return null if the Enum constant does not exist.

Parameters:
enumClass the Class of the Enum declaring the constant values.
 
   public static <T extends Enum<T>> Function<String, T> valueOfFunction(Class<T> enumClass) {
     return new ValueOfFunction<T>(enumClass);
   }

  
A Function that maps an Enum name to the associated constant, or null if the constant does not exist.
 
   private static final class ValueOfFunction<T extends Enum<T>>
       implements Function<String, T>, Serializable {
 
     private final Class<T> enumClass;
 
     private ValueOfFunction(Class<T> enumClass) {
       this. = checkNotNull(enumClass);
     }
 
     @Override
     public T apply(String value) {
       try {
         return Enum.valueOf(value);
       } catch (IllegalArgumentException e) {
         return null;
       }
     }
 
     @Override public boolean equals(@Nullable Object obj) {
       return obj instanceof ValueOfFunction &&
           .equals(((ValueOfFunctionobj).);
     }
 
    @Override public int hashCode() {
      return .hashCode();
    }
    @Override public String toString() {
      return "Enums.valueOf(" +  + ")";
    }
    private static final long serialVersionUID = 0;
  }

  
Returns an optional enum constant for the given type, using Enum.valueOf. If the constant does not exist, Optional.absent is returned. A common use case is for parsing user input or falling back to a default enum constant. For example, Enums.getIfPresent(Country.class, countryInput).or(Country.DEFAULT);

Since:
12.0
  public static <T extends Enum<T>> Optional<T> getIfPresent(Class<T> enumClassString value) {
    checkNotNull(enumClass);
    checkNotNull(value);
    try {
      return Optional.of(Enum.valueOf(enumClassvalue));
    } catch (IllegalArgumentException iae) {
      return Optional.absent();
    }
  }
New to GrepCode? Check out our FAQ X