How to use

SharedUtils

in

javax.faces.component

static Map<String, List<String>> evaluateExpressions(FacesContext context, Map<String, List<String>> map) {
  if (map != null && !map.isEmpty()) {
    Map<String, List<String>> ret = new HashMap<String, List<String>>(map.size());
    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
      ret.put(entry.getKey(), evaluateExpressions(context, entry.getValue()));
    }
    
    return ret;
  }
  
  return map;
}
 

static boolean isMixedExpression(String expression) {
  if (null == expression) {
    return false;
  }
  // if it doesn't start and end with delimiters
  return (!(expression.startsWith("#{") && expression.endsWith("}")))
       && isExpression(expression);
}

static boolean isMixedExpression(String expression) {
  if (null == expression) {
    return false;
  }
  // if it doesn't start and end with delimiters
  return (!(expression.startsWith("#{") && expression.endsWith("}")))
       && isExpression(expression);
}

static Map<String, List<String>> evaluateExpressions(FacesContext context, Map<String, List<String>> map) {
  if (map != null && !map.isEmpty()) {
    Map<String, List<String>> ret = new HashMap<String, List<String>>(map.size());
    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
      ret.put(entry.getKey(), evaluateExpressions(context, entry.getValue()));
    }
    
    return ret;
  }
  
  return map;
}
 

static boolean isMixedExpression(String expression) {
  if (null == expression) {
    return false;
  }
  // if it doesn't start and end with delimiters
  return (!(expression.startsWith("#{") && expression.endsWith("}")))
       && isExpression(expression);
}

static Map<String, List<String>> evaluateExpressions(FacesContext context, Map<String, List<String>> map) {
  if (map != null && !map.isEmpty()) {
    Map<String, List<String>> ret = new HashMap<String, List<String>>(map.size());
    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
      ret.put(entry.getKey(), evaluateExpressions(context, entry.getValue()));
    }
    
    return ret;
  }
  
  return map;
}
 

static boolean isMixedExpression(String expression) {
  if (null == expression) {
    return false;
  }
  // if it doesn't start and end with delimiters
  return (!(expression.startsWith("#{") && expression.endsWith("}")))
       && isExpression(expression);
}

static Map<String, List<String>> evaluateExpressions(FacesContext context, Map<String, List<String>> map) {
  if (map != null && !map.isEmpty()) {
    Map<String, List<String>> ret = new HashMap<String, List<String>>(map.size());
    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
      ret.put(entry.getKey(), evaluateExpressions(context, entry.getValue()));
    }
    
    return ret;
  }
  
  return map;
}
 

static boolean isMixedExpression(String expression) {
  if (null == expression) {
    return false;
  }
  // if it doesn't start and end with delimiters
  return (!(expression.startsWith("#{") && expression.endsWith("}")))
       && isExpression(expression);
}

static Map<String, List<String>> evaluateExpressions(FacesContext context, Map<String, List<String>> map) {
  if (map != null && !map.isEmpty()) {
    Map<String, List<String>> ret = new HashMap<String, List<String>>(map.size());
    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
      ret.put(entry.getKey(), evaluateExpressions(context, entry.getValue()));
    }
    
    return ret;
  }
  
  return map;
}
 

static boolean isMixedExpression(String expression) {
  if (null == expression) {
    return false;
  }
  // if it doesn't start and end with delimiters
  return (!(expression.startsWith("#{") && expression.endsWith("}")))
       && isExpression(expression);
}

static Map<String, List<String>> evaluateExpressions(FacesContext context, Map<String, List<String>> map) {
  if (map != null && !map.isEmpty()) {
    Map<String, List<String>> ret = new HashMap<String, List<String>>(map.size());
    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
      ret.put(entry.getKey(), evaluateExpressions(context, entry.getValue()));
    }
    
    return ret;
  }
  
  return map;
}
 

static boolean isMixedExpression(String expression) {
  if (null == expression) {
    return false;
  }
  // if it doesn't start and end with delimiters
  return (!(expression.startsWith("#{") && expression.endsWith("}")))
       && isExpression(expression);
}

static Map<String, List<String>> evaluateExpressions(FacesContext context, Map<String, List<String>> map) {
  if (map != null && !map.isEmpty()) {
    Map<String, List<String>> ret = new HashMap<String, List<String>>(map.size());
    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
      ret.put(entry.getKey(), evaluateExpressions(context, entry.getValue()));
    }
    
    return ret;
  }
  
  return map;
}
 

static boolean isMixedExpression(String expression) {
  if (null == expression) {
    return false;
  }
  // if it doesn't start and end with delimiters
  return (!(expression.startsWith("#{") && expression.endsWith("}")))
       && isExpression(expression);
}

static Map<String, List<String>> evaluateExpressions(FacesContext context, Map<String, List<String>> map) {
  if (map != null && !map.isEmpty()) {
    Map<String, List<String>> ret = new HashMap<String, List<String>>(map.size());
    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
      ret.put(entry.getKey(), evaluateExpressions(context, entry.getValue()));
    }
    
    return ret;
  }
  
  return map;
}
 

static List<String> evaluateExpressions(FacesContext context, List<String> values) {
   if (!values.isEmpty()) {
     List<String> ret = new ArrayList<String>(values.size());
     Application app = context.getApplication();
     for (String val : values) {
       if (val != null) {
         String value = val.trim();
         if (isExpression(value)) {
           value = app.evaluateExpressionGet(context,
                            value,
                            String.class);
         }
         ret.add(value);
       }
     }
          return ret;
   }
   return values;
 }

static List<String> evaluateExpressions(FacesContext context, List<String> values) {
   if (!values.isEmpty()) {
     List<String> ret = new ArrayList<String>(values.size());
     Application app = context.getApplication();
     for (String val : values) {
       if (val != null) {
         String value = val.trim();
         if (isExpression(value)) {
           value = app.evaluateExpressionGet(context,
                            value,
                            String.class);
         }
         ret.add(value);
       }
     }
          return ret;
   }
   return values;
 }

static List<String> evaluateExpressions(FacesContext context, List<String> values) {
   if (!values.isEmpty()) {
     List<String> ret = new ArrayList<String>(values.size());
     Application app = context.getApplication();
     for (String val : values) {
       if (val != null) {
         String value = val.trim();
         if (isExpression(value)) {
           value = app.evaluateExpressionGet(context,
                            value,
                            String.class);
         }
         ret.add(value);
       }
     }
          return ret;
   }
   return values;
 }

static List<String> evaluateExpressions(FacesContext context, List<String> values) {
   if (!values.isEmpty()) {
     List<String> ret = new ArrayList<String>(values.size());
     Application app = context.getApplication();
     for (String val : values) {
       if (val != null) {
         String value = val.trim();
         if (isExpression(value)) {
           value = app.evaluateExpressionGet(context,
                            value,
                            String.class);
         }
         ret.add(value);
       }
     }
          return ret;
   }
   return values;
 }