public static boolean componentIsDisabled(UIComponent component) 
{
        return (Boolean.valueOf(String.valueOf(component.getAttributes().get("disabled"))));
}

 public static boolean componentIsDisabledOrReadonly(UIComponent component) 
{
        return Boolean.valueOf(String.valueOf(component.getAttributes().get("disabled"))) || Boolean.valueOf(String.valueOf(component.getAttributes().get("readonly")));
}

 public static String getContentTypeFromResponse(Object response) 
{
        String result = null;
        if (null != response) {           
            try {
                Method method = ReflectionUtils.lookupMethod(
                      response.getClass(),
                      "getContentType",
                      RIConstants.EMPTY_CLASS_ARGS
                );
                if (null != method) {
                    Object obj =
                          method.invoke(response, RIConstants.EMPTY_METH_ARGS);
                    if (null != obj) {
                        result = obj.toString();
                    }
                }
            } catch (Exception e) {
                throw new FacesException(e);
            }
        }
        return result;
}

PRECONDITION: argument response is non-null and has a method called getContentType that takes no arguments and returns a String, with no side-effects.

This method allows us to get the contentType in both the servlet and portlet cases, without introducing a compile-time dependency on the portlet api.

 public static Converter getConverterForClass(Class converterClass,
    FacesContext context) 
{
        if (converterClass == null) {
            return null;
        }
        try {            
            Application application = context.getApplication();
            return (application.createConverter(converterClass));
        } catch (Exception e) {
            return (null);
        }
}

 public static Converter getConverterForIdentifer(String converterId,
    FacesContext context) 
{
        if (converterId == null) {
            return null;
        }
        try {            
            Application application = context.getApplication();
            return (application.createConverter(converterId));
        } catch (Exception e) {
            return (null);
        }
}

 public static ClassLoader getCurrentLoader(Object fallbackClass) 
{
        ClassLoader loader =
            Thread.currentThread().getContextClassLoader();
        if (loader == null) {
            loader = fallbackClass.getClass().getClassLoader();
        }
        return loader;
}

 public static String getFacesMapping(FacesContext context) 
{
        if (context == null) {
            String message = MessageUtils.getExceptionMessageString
                  (MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "context");
            throw new NullPointerException(message);
        }
        // Check for a previously stored mapping   
        ExternalContext extContext = context.getExternalContext();
        String mapping =
              (String) RequestStateManager.get(context, RequestStateManager.INVOCATION_PATH);
        if (mapping == null) {
            // first check for javax.servlet.forward.servlet_path
            // and javax.servlet.forward.path_info for non-null
            // values.  if either is non-null, use this
            // information to generate determine the mapping.
            String servletPath = extContext.getRequestServletPath();
            String pathInfo = extContext.getRequestPathInfo();
            mapping = getMappingForRequest(servletPath, pathInfo);
            if (mapping == null) {
                if (LOGGER.isLoggable(Level.FINE)) {
                    LOGGER.log(Level.FINE,
                               "jsf.faces_servlet_mapping_cannot_be_determined_error",
                               new Object[]{servletPath});
                }
            }
        }
        // if the FacesServlet is mapped to /* throw an 
        // Exception in order to prevent an endless 
        // RequestDispatcher loop
        //if ("/*".equals(mapping)) {
        //    throw new FacesException(MessageUtils.getExceptionMessageString(
        //          MessageUtils.FACES_SERVLET_MAPPING_INCORRECT_ID));
        //}
        if (mapping != null) {
            RequestStateManager.set(context,
                                    RequestStateManager.INVOCATION_PATH,
                                    mapping);
        }
        if (LOGGER.isLoggable(Level.FINE)) {
            LOGGER.log(Level.FINE,
                       "URL pattern of the FacesServlet executing the current request "
                       + mapping);
        }
        return mapping;
}

Returns the URL pattern of the javax.faces.webapp.FacesServlet that is executing the current request. If there are multiple URL patterns, the value returned by HttpServletRequest.getServletPath() and HttpServletRequest.getPathInfo() is used to determine which mapping to return.

If no mapping can be determined, it most likely means that this particular request wasn't dispatched through the javax.faces.webapp.FacesServlet .

 public static FeatureDescriptor getFeatureDescriptor(String name,
    String displayName,
    String desc,
    boolean expert,
    boolean hidden,
    boolean preferred,
    Object type,
    Boolean designTime) 
{
            
        FeatureDescriptor fd = new FeatureDescriptor();
        fd.setName(name);
        fd.setDisplayName(displayName);
        fd.setShortDescription(desc);
        fd.setExpert(expert);
        fd.setHidden(hidden);
        fd.setPreferred(preferred);
        fd.setValue(ELResolver.TYPE, type);
        fd.setValue(ELResolver.RESOLVABLE_AT_DESIGN_TIME, designTime);
        return fd;
}

 public static Object getListenerInstance(ValueExpression type,
    ValueExpression binding) 
{
        FacesContext faces = FacesContext.getCurrentInstance();
        Object instance = null;
        if (faces == null) {
            return null;
        }
        if (binding != null) {
            instance = binding.getValue(faces.getELContext());
        }
        if (instance == null && type != null) {
            try {
                instance = ReflectionUtils.newInstance(((String) type.getValue(faces.getELContext())));
            } catch (Exception e) {
                throw new AbortProcessingException(e.getMessage(), e);
            }
            if (binding != null) {
                binding.setValue(faces.getELContext(), instance);
            }
        }
        return instance;
}

Factory method for creating the varius JSF listener instances that may be referenced by type or binding.

If binding is not null and the evaluation result is not null return that instance. Otherwise try to instantiate an instances based on type.

 public static Locale getLocaleFromContextOrSystem(FacesContext context) 
{
        Locale result, temp = Locale.getDefault();
        UIViewRoot root;
        result = temp;
        if (null != context) {
            if (null != (root = context.getViewRoot())) {
                if (null == (result = root.getLocale())) {
                    result = temp;
                }
            }
        }
        return result;
}

 public static Locale getLocaleFromString(String localeStr) throws IllegalArgumentException 
{
        // length must be at least 2.
        if (null == localeStr || localeStr.length() <  2) {
            throw new IllegalArgumentException("Illegal locale String: " +
                                               localeStr);
        }
        Locale result = null;
        String lang = null;
        String country = null;
        String variant = null;
        char[] seps = {
            '-",
            '_"
        };
        int i = 0;
        int j = 0;
        int inputLength = localeStr.length();
        // to have a language, the length must be  >= 2
        if ((inputLength  >= 2) &&
            ((i = indexOfSet(localeStr, seps, 0)) == -1)) {
            // we have only Language, no country or variant
            if (inputLength != 2) {
                throw new
                    IllegalArgumentException("Illegal locale String: " +
                                             localeStr);
            }
            lang = localeStr.toLowerCase();
        }
        // we have a separator, it must be either '-' or '_'
        if (i != -1) {
            lang = localeStr.substring(0, i);
            // look for the country sep.
            // to have a country, the length must be  >= 5
            if ((inputLength  >= 5) &&
                ((j = indexOfSet(localeStr, seps, i + 1)) == -1)) {
                // no further separators, length must be 5
                if (inputLength != 5) {
                    throw new
                        IllegalArgumentException("Illegal locale String: " +
                                                 localeStr);
                }
                country = localeStr.substring(i + 1);
            }
            if (j != -1) {
                country = localeStr.substring(i + 1, j);
                // if we have enough separators for language, locale,
                // and variant, the length must be  >= 8.
                if (inputLength  >= 8) {
                    variant = localeStr.substring(j + 1);
                } else {
                    throw new
                        IllegalArgumentException("Illegal locale String: " +
                                                 localeStr);
                }
            }
        }
        if (variant != null && country != null && lang != null) {
            result = new Locale(lang, country, variant);
        } else if (lang != null && country != null) {
            result = new Locale(lang, country);
        } else if (lang != null) {
            result = new Locale(lang, "");
        }
        return result;
}

 public static String getStackTraceString(Throwable e) 
{
        if (null == e) {
            return "";
        }
        StackTraceElement[] stacks = e.getStackTrace();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i <  stacks.length; i++) {
            sb.append(stacks[i].toString()).append('\n");
        }
        return sb.toString();
}

Leverage the Throwable.getStackTrace() method to produce a String version of the stack trace, with a "\n" before each line.

 public static StateManager getStateManager(FacesContext context) throws FacesException 
{
        return (context.getApplication().getStateManager());
}

 public static ViewHandler getViewHandler(FacesContext context) throws FacesException 
{
        // Get Application instance
        Application application = context.getApplication();
        assert (application != null);
        // Get the ViewHandler
        ViewHandler viewHandler = application.getViewHandler();
        assert (viewHandler != null);
        return viewHandler;
}

 public static int indexOfSet(String str,
    char[] set,
    int fromIndex) 
{
        int result = -1;
        for (int i = fromIndex, len = str.length(); i <  len; i++) {
            for (int j = 0, innerLen = set.length; j <  innerLen; j++) {
                if (str.charAt(i) == set[j]) {
                    result = i;
                    break;
                }
            }
            if (result != -1) {
                break;
            }
        }
        return result;
}

 public static boolean isCoreTLVActive() 
{
        return coreTLVEnabled;
}

 public static boolean isHtmlTLVActive() 
{
        return htmlTLVEnabled;
}

 public static boolean isPrefixMapped(String mapping) 
{
        return (mapping.charAt(0) == '/");
}

Returns true if the provided url-mapping is a prefix path mapping (starts with /).

 public static boolean isUnitTestModeEnabled() 
{
        return unitTestModeEnabled;
}

 public static Class loadClass(String name,
    Object fallbackClass) throws ClassNotFoundException 
{
        ClassLoader loader = Util.getCurrentLoader(fallbackClass);
        // Where to begin...
        // JDK 6 introduced CR 6434149 where one couldn't pass
        // in a literal for an array type ([Ljava.lang.String) and
        // get the Class representation using ClassLoader.loadClass().
        // It was recommended to use Class.forName(String, boolean, ClassLoader)
        // for all ClassLoading requests.
        // HOWEVER, when trying to eliminate the need for .groovy extensions
        // being specified in the faces-config.xml for Groovy-based artifacts,
        // by using a an adapter to the GroovyScriptEngine, I found that the class
        // instance was cached somewhere, so that no matter what change I made,
        // Class.forName() always returned the same instance.  I haven't been
        // able to determine why this happens in the appserver environment
        // as the same adapter in a standalone program works as one might expect.
        // So, for now, if the classname starts with '[', then use Class.forName()
        // to avoid CR 643419 and for all other cases, use ClassLoader.loadClass().
        if (name.charAt(0) == '[") {
            return Class.forName(name, true, loader);
        } else {
            return loader.loadClass(name);
        }
}

 public static  void notNull(String varname,
    Object var) 
{
        if (var == null) {
            throw new NullPointerException(
                  MessageUtils.getExceptionMessageString(
                      MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, varname));
        }
}

 public static  void parameterNonEmpty(String param) throws FacesException 
{
        if (null == param || 0 == param.length()) {
            throw new FacesException(MessageUtils.getExceptionMessageString(MessageUtils.EMPTY_PARAMETER_ID));
        }
}

 public static  void parameterNonNull(Object param) throws FacesException 
{
        if (null == param) {
            throw new FacesException(
                MessageUtils.getExceptionMessageString(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "param"));
        }
}

 public static boolean prefixViewTraversal(FacesContext context,
    UIComponent root,
    Util.TreeTraversalCallback action) throws FacesException 
{
        boolean keepGoing;
        if (keepGoing = action.takeActionOnNode(context, root)) {
            Iterator< UIComponent > kids = root.getFacetsAndChildren();
            while (kids.hasNext() && keepGoing) {
                keepGoing = prefixViewTraversal(context,
                                                kids.next(),
                                                action);
            }
        }
        return keepGoing;
}

 public static  void setCoreTLVActive(boolean active) 
{
        coreTLVEnabled = active;
}

 public static  void setHtmlTLVActive(boolean active) 
{
        htmlTLVEnabled = active;
}

 public static  void setUnitTestModeEnabled(boolean enabled) 
{
        unitTestModeEnabled = enabled;
}

 public static synchronized String[] split(String toSplit,
    String regex) 
{
        Pattern pattern = patternCache.get(regex);
        if (pattern == null) {
            pattern = Pattern.compile(regex);
            patternCache.put(regex, pattern);
        }
        return pattern.split(toSplit, 0);
}

A slightly more efficient version of String.split() which caches the Patterns in an LRUMap instead of creating a new Pattern on each invocation.