Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you 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 org.apache.myfaces.commons.converter;
 
 
Converts a Java 5 Enum. see Javadoc of JSF Specification

Author(s):
Stan Silvert
 
    name = "mcc:convertEnum",
    tagClass = "org.apache.myfaces.commons.converter.ConvertEnumTag",
    tagHandler = "org.apache.myfaces.commons.converter.ConvertEnumTagHandler",
    serialuidtag = "3864584277821896141L")
 public class EnumConverter implements ConverterPartialStateHolder {
     
     public static final String CONVERTER_ID = "org.apache.myfaces.commons.converter.Enum";
     public static final String ENUM_ID = "org.apache.myfaces.commons.converter.EnumConverter.ENUM";
     public static final String ENUM_NO_CLASS_ID = "org.apache.myfaces.commons.converter.EnumConverter.ENUM_NO_CLASS";
     public static final String ENUM_NO_ENUM_CLASS = "org.apache.myfaces.commons.converter.EnumConverter.ENUM_NO_ENUM_CLASS";
     public static final String SEPARATOR = "#";
 
     private Class targetClass;
     
     private boolean isTransient = false;
    
    
Creates a new instance of EnumConverter
 
     public EnumConverter() {
     }
     
     public EnumConverter(Class targetClass) {
         if (!targetClass.isEnum()) throw new IllegalArgumentException("targetClass for EnumConverter must be an Enum");
         this. = targetClass;
     }
 
     public String getAsString(FacesContext facesContextUIComponent uiComponentObject valuethrows ConverterException {
         if (facesContext == nullthrow new NullPointerException("facesContext can not be null");
         if (uiComponent == nullthrow new NullPointerException("uiComponent can not be null");
         if (value == nullreturn "";
 
       Class converterClass = null;
       String idPrefix = "";
 
       if ( != null) {
         converterClass = ;
       } else if (value.getClass().isEnum()) {
         converterClass = value.getClass();
         idPrefix = value.getClass().getName() + ;
       } else if (value.getClass().getDeclaringClass() != null && value.getClass().getDeclaringClass().isEnum()) {
         converterClass = value.getClass().getDeclaringClass();
         idPrefix = value.getClass().getDeclaringClass().getName() + ;
       }
 
       if (converterClass == null ||  != null) {
         checkTargetClass(facesContextuiComponentvalueconverterClass);
       }
 
       for (Object enumConstant : converterClass.getEnumConstants()) {
         if (enumConstant == value) {
           return idPrefix + ((Enum)enumConstant).name();
         }
       }
 
         return value.toString();
     }
 
     public Object getAsObject(FacesContext facesContextUIComponent uiComponentString valuethrows ConverterException {
         if (facesContext == nullthrow new NullPointerException("facesContext");
         if (uiComponent == nullthrow new NullPointerException("uiComponent");
        if (value == null)  return null;
        value = value.trim();
        if (value.length() == 0)  return null;
      Class converterClass = null;
      String enumName = null;
      if ( != null) {
        enumName = value;
        converterClass = ;
      } else if (value.indexOf() > 0) {
        int index = value.indexOf();
        if (index < value.length() - 2) {
          String className = value.substring(0, index);
          enumName = value.substring(index +1);
          try {
            converterClass = Class.forName(className);
          } catch (ClassNotFoundException e) {
  //          LOG.error("Catched: " + e.getMessage(), e);
          }
        }
        if (enumName == null || enumName.length() == 0) {
          return null;
        }
      }
      if (converterClass == null) {
        checkTargetClass(facesContextuiComponentvalueconverterClass);
      }
        // we know targetClass and value can't be null, so we can use Enum.valueOf
        // instead of the hokey looping called for in the javadoc
        try {
          //noinspection unchecked
          return Enum.valueOf(converterClassenumName);
        } catch (IllegalArgumentException e) {
            Object[] params = new Object[]{value
                                           firstConstantOfEnum(), 
                                           MessageUtils.getLabel(facesContextuiComponent)};
            
            throw new ConverterException(MessageUtils.getMessage(.,
                                                                       ,
                                                                       params));
        }
    }
    private void checkTargetClass(FacesContext facesContextUIComponent uiComponentObject valueClass converterClass) {
        if (converterClass == null) {
            Object[] params = new Object[]{value, MessageUtils.getLabel(facesContextuiComponent)};
            throw new ConverterException(MessageUtils.getMessage(.,
                                                                       
                                                                       params));
        }
        if (!converterClass.isEnum())
        {
            Object[] params = new Object[]{value, MessageUtils.getLabel(facesContextuiComponent)};
            throw new ConverterException(MessageUtils.getMessage(.,
                                                                       
                                                                       params));
        }
    }
    // find the first constant value of the targetClass and return as a String
    private String firstConstantOfEnum() {
        Object[] enumConstants.getEnumConstants();
        if (enumConstants.length != 0 ) return enumConstants[0].toString();
        
        return ""// if empty Enum
    }
    public void restoreState(FacesContext contextObject state) {
        if (state != null)
        {
             = (Class)state;
        }
    }
    public Object saveState(FacesContext context) {
        if (!initialStateMarked())
        {
            return ;
        }
        return null;
    }
    public void setTransient(boolean newTransientValue) {
         = newTransientValue;
    }
    public boolean isTransient() {
        return ;
    }

    
The enum class to be used for this converter as reference
    public Class getTargetClass()
    {
        return ;
    }
    public void setTargetClass(Class targetClass)
    {
        this. = targetClass;
        clearInitialState();
    }
    
    private boolean _initialStateMarked = false;
    public void clearInitialState()
    {
         = false;
    }
    public boolean initialStateMarked()
    {
        return ;
    }
    public void markInitialState()
    {
         = true;
    }
New to GrepCode? Check out our FAQ X